Class: Prism::Translation::Parser::Compiler

Relationships & Source Files
Namespace Children
Exceptions: `CompilationError`
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, Prism::Compiler
Instance Chain: self, Prism::Compiler
Inherits:	Prism::Compiler Object Prism::Compiler Prism::Translation::Parser::Compiler
Defined in:	lib/prism/translation/parser/compiler.rb

Overview

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

Constant Summary

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.

# File 'lib/prism/translation/parser/compiler.rb', line 2003
```
::Parser::Source::Range
```

Class Method Summary

.new(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false) ⇒ Compiler constructor

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

Instance Attribute Summary

#builder readonly

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

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

Whether or not the current node is in a destructure.
#in_pattern readonly

Whether or not the current node is in a pattern.
#offset_cache readonly

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

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

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

Instance Method Summary

#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.
#visit_back_reference_read_node(node)

$+ ^^.
#visit_begin_node(node)

begin end ^^^^^^^^^.
#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 ^^^^^.
#visit_call_and_write_node(node)

foo.bar &&= baz ^^^^^^^^^^^^^^^.
#visit_call_node(node)

foo ^^^.
#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 ^^^^^^^^^^^^.
#visit_constant_read_node(node)

Foo ^^^.
#visit_constant_target_node(node)

Foo, = bar ^^^.
#visit_constant_write_node(node)

Foo = 1 ^^^^^^^.
#visit_def_node(node)

def foo; end ^^^^^^^^^^^^.
#visit_defined_node(node)

defined? a ^^^^^^^^^^.
#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)

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 ^^^^^.
#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_if_node(node)

if foo then bar end ^^^^^^^^^^^^^^^^^^^.
#visit_imaginary_node(node)

1i ^^.
#visit_implicit_node(node)

{ foo: }
#visit_implicit_rest_node(node)

foo { |bar,| }
#visit_in_node(node)

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^.
#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_instance_variable_and_write_node(node)

^^^^^^^^^^^^.
#visit_instance_variable_operator_write_node(node)

^^^^^^^^^^^.
#visit_instance_variable_or_write_node(node)

^^^^^^^^^^^^.
#visit_instance_variable_read_node(node)

^^^^.
#visit_instance_variable_target_node(node)

@foo, = bar ^^^^.
#visit_instance_variable_write_node(node)

^^^^^^^^.
#visit_integer_node(node)

1 ^.
#visit_interpolated_match_last_line_node(node)

Alias for #visit_interpolated_regular_expression_node.
#visit_interpolated_regular_expression_node(node) (also: #visit_interpolated_match_last_line_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.
#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)

Alias for #visit_regular_expression_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.
#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 ^^^^.
#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_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)

() ^^.
#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) (also: #visit_flip_flop_node)

0..5 ^^^^.
#visit_rational_node(node)

1r ^^.
#visit_redo_node(node)

redo ^^^^.
#visit_regular_expression_node(node) (also: #visit_match_last_line_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.
#visit_retry_node(node)

retry ^^^^^.
#visit_return_node(node)

return ^^^^^^.
#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).
#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 ^^^^^^^^^^^^^^^^^^^.
#visit_until_node(node)

until foo; bar end ^^^^^^^^^^^^^^^^^^.
#visit_when_node(node)

case foo; when bar; end.
#visit_while_node(node)

while foo; bar end ^^^^^^^^^^^^^^^^^^.
#visit_x_string_node(node)

foo ^^^^^.
#visit_yield_node(node)

yield ^^^^^.
#copy_compiler(forwarding: self.forwarding, in_destructure: self.in_destructure, in_pattern: self.in_pattern) private

Initialize a new compiler with the given option overrides, used to visit a subtree with the given options.
#find_forwarding(node) private

When *, **, &, or …
#multi_target_elements(node) private

Returns the set of targets for a MultiTargetNode or a MultiWriteNode.
#numeric_negate(message_loc, receiver) private

Negate the value of a numeric node.
#procarg0?(parameters) ⇒ Boolean private

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) private

Constructs a new source range from the given start and end offsets.
#srange_find(start_offset, end_offset, character) private

Constructs a new source range by finding the given character between the given start offset and end offset.
#srange_offsets(start_offset, end_offset) private

Constructs a new source range from the given start and end offsets.
#string_nodes_from_interpolation(node, opening) private

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) private

Create parser string nodes from a single prism node.
#token(location) private

Transform a location into a token that the parser gem expects.
#visit_block(call, block) private

Visit a block node on a call.
#visit_heredoc(node) private

Visit a heredoc that can be either a string or an xstring.
#visit_numeric(node, value) private

Visit a numeric node and account for the optional sign.
#within_pattern private

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

Constructor Details

.new(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false) ⇒ `Compiler`

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 40


def initialize(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false)
  @parser = parser
  @builder = parser.builder
  @source_buffer = parser.source_buffer
  @offset_cache = offset_cache

  @forwarding = forwarding
  @in_destructure = in_destructure
  @in_pattern = in_pattern
end

Instance Attribute Details

#builder (readonly)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 19


attr_reader :builder

#forwarding (readonly)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 30


attr_reader :forwarding

#in_destructure (readonly)

Whether or not the current node is in a destructure.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 33


attr_reader :in_destructure

#in_pattern (readonly)

Whether or not the current node is in a pattern.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 36


attr_reader :in_pattern

#offset_cache (readonly)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 27


attr_reader :offset_cache

#parser (readonly)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 15


attr_reader :parser

#source_buffer (readonly)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 23


attr_reader :source_buffer

Instance Method Details

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1943


def copy_compiler(forwarding: self.forwarding, in_destructure: self.in_destructure, in_pattern: self.in_pattern)
  Compiler.new(parser, offset_cache, forwarding: forwarding, in_destructure: in_destructure, in_pattern: in_pattern)
end

#find_forwarding(node) (private)

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.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1950


def find_forwarding(node)
  return [] if node.nil?

  forwarding = []
  forwarding << :* if node.rest.is_a?(RestParameterNode) && node.rest.name.nil?
  forwarding << :** if node.keyword_rest.is_a?(KeywordRestParameterNode) && node.keyword_rest.name.nil?
  forwarding << :& if !node.block.nil? && node.block.name.nil?
  forwarding |= [:&, :"..."] if node.keyword_rest.is_a?(ForwardingParameterNode)

  forwarding
end

#multi_target_elements(node) (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1963


def multi_target_elements(node)
  elements = [*node.lefts]
  elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
  elements.concat(node.rights)
  elements
end

#numeric_negate(message_loc, receiver) (private)

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.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1975


def numeric_negate(message_loc, receiver)
  case receiver.type
  when :integer_node, :float_node
    receiver.copy(value: -receiver.value, location: message_loc.join(receiver.location))
  when :rational_node
    receiver.copy(numerator: -receiver.numerator, location: message_loc.join(receiver.location))
  when :imaginary_node
    receiver.copy(numeric: numeric_negate(message_loc, receiver.numeric), location: message_loc.join(receiver.location))
  end
end

#procarg0?(parameters) ⇒ `Boolean` (private)

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.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1989


def procarg0?(parameters)
  parameters &&
    parameters.requireds.length == 1 &&
    parameters.optionals.empty? &&
    parameters.rest.nil? &&
    parameters.posts.empty? &&
    parameters.keywords.empty? &&
    parameters.keyword_rest.nil? &&
    parameters.block.nil?
end

#srange(location) (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2006


def srange(location)
  Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset]) if location
end

#srange_find(start_offset, end_offset, character) (private)

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.

Note that end_offset is allowed to be nil, in which case this will search until the end of the string.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2021


def srange_find(start_offset, end_offset, character)
  if (match = source_buffer.source.byteslice(start_offset...end_offset)[/\A\s*#{character}/])
    final_offset = start_offset + match.bytesize
    [character, Range.new(source_buffer, offset_cache[final_offset - character.bytesize], offset_cache[final_offset])]
  end
end

#srange_offsets(start_offset, end_offset) (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2011


def srange_offsets(start_offset, end_offset)
  Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
end

#string_nodes_from_interpolation(node, opening) (private)

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.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2138


def string_nodes_from_interpolation(node, opening)
  node.parts.flat_map do |part|
    if part.type == :string_node && part.content.include?("\n") && part.opening_loc.nil?
      string_nodes_from_line_continuations(part.unescaped, part.content, part.content_loc.start_offset, opening)
    else
      visit(part)
    end
  end
end

#string_nodes_from_line_continuations(unescaped, escaped, start_offset, opening) (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2150


def string_nodes_from_line_continuations(unescaped, escaped, start_offset, opening)
  unescaped = unescaped.lines
  escaped = escaped.lines
  percent_array = opening&.start_with?("%w", "%W", "%i", "%I")
  regex = opening == "/" || opening&.start_with?("%r")

  # Non-interpolating strings
  if opening&.end_with?("'") || opening&.start_with?("%q", "%s", "%w", "%i")
    current_length = 0
    current_line = +""

    escaped.filter_map.with_index do |escaped_line, index|
      unescaped_line = unescaped.fetch(index, "")
      current_length += escaped_line.bytesize
      current_line << unescaped_line

      # Glue line continuations together. Only %w and %i arrays can contain these.
      if percent_array && escaped_line[/(\\)*\n$/, 1]&.length&.odd?
        next unless index == escaped.count - 1
      end
      s = builder.string_internal([current_line, srange_offsets(start_offset, start_offset + current_length)])
      start_offset += escaped_line.bytesize
      current_line = +""
      current_length = 0
      s
    end
  else
    escaped_lengths = []
    normalized_lengths = []
    # Keeps track of where an unescaped line should start a new token. An unescaped
    # \n would otherwise be indistinguishable from the actual newline at the end of
    # of the line. The parser gem only emits a new string node at "real" newlines,
    # line continuations don't start a new node as well.
    do_next_tokens = []

    escaped
      .chunk_while { |before, after| before[/(\\*)\r?\n$/, 1]&.length&.odd? || false }
      .each do |lines|
        escaped_lengths << lines.sum(&:bytesize)

        unescaped_lines_count =
          if regex
            0 # Will always be preserved as is
          else
            lines.sum do |line|
              count = line.scan(/(\\*)n/).count { |(backslashes)| backslashes&.length&.odd? }
              count -= 1 if !line.end_with?("\n") && count > 0
              count
            end
          end

        extra = 1
        extra = lines.count if percent_array # Account for line continuations in percent arrays

        normalized_lengths.concat(Array.new(unescaped_lines_count + extra, 0))
        normalized_lengths[-1] = lines.sum { |line| line.bytesize }
        do_next_tokens.concat(Array.new(unescaped_lines_count + extra, false))
        do_next_tokens[-1] = true
      end

    current_line = +""
    current_normalized_length = 0

    emitted_count = 0
    unescaped.filter_map.with_index do |unescaped_line, index|
      current_line << unescaped_line
      current_normalized_length += normalized_lengths.fetch(index, 0)

      if do_next_tokens[index]
        inner_part = builder.string_internal([current_line, srange_offsets(start_offset, start_offset + current_normalized_length)])
        start_offset += escaped_lengths.fetch(emitted_count, 0)
        current_line = +""
        current_normalized_length = 0
        emitted_count += 1
        inner_part
      else
        nil
      end
    end
  end
end

#token(location) (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2029


def token(location)
  [location.slice, Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset])] if location
end

#visit_alias_global_variable_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 59


def visit_alias_global_variable_node(node)
  builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
end

#visit_alias_method_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 53


def visit_alias_method_node(node)
  builder.alias(token(node.keyword_loc), visit(node.new_name), visit(node.old_name))
end

#visit_alternation_pattern_node(node)

foo => bar | baz

^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 65


def visit_alternation_pattern_node(node)
  builder.match_alt(visit(node.left), token(node.operator_loc), visit(node.right))
end

#visit_and_node(node)

a and b ^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 71


def visit_and_node(node)
  builder.logical_op(:and, visit(node.left), token(node.operator_loc), visit(node.right))
end

#visit_arguments_node(node)

foo(bar)

^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 128


def visit_arguments_node(node)
  visit_all(node.arguments)
end

#visit_array_node(node)

: ^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 77


def visit_array_node(node)
  if node.opening&.start_with?("%w", "%W", "%i", "%I")
    elements = node.elements.flat_map do |element|
      if element.is_a?(StringNode)
        if element.content.include?("\n")
          string_nodes_from_line_continuations(element.unescaped, element.content, element.content_loc.start_offset, node.opening)
        else
          [builder.string_internal([element.unescaped, srange(element.content_loc)])]
        end
      elsif element.is_a?(InterpolatedStringNode)
        builder.string_compose(
          token(element.opening_loc),
          string_nodes_from_interpolation(element, node.opening),
          token(element.closing_loc)
        )
      else
        [visit(element)]
      end
    end
  else
    elements = visit_all(node.elements)
  end

  builder.array(token(node.opening_loc), elements, token(node.closing_loc))
end

#visit_array_pattern_node(node)

foo => [bar]

^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 105


def visit_array_pattern_node(node)
  elements = [*node.requireds]
  elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
  elements.concat(node.posts)
  visited = visit_all(elements)

  if node.rest.is_a?(ImplicitRestNode)
    visited[-1] = builder.match_with_trailing_comma(visited[-1], token(node.rest.location))
  end

  if node.constant
    if visited.empty?
      builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc)), token(node.closing_loc))
    else
      builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(nil, visited, nil), token(node.closing_loc))
    end
  else
    builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc))
  end
end

#visit_assoc_node(node)

{ a: 1 }

^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 134


def visit_assoc_node(node)
  key = node.key

  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)])
        else
          builder.match_hash_var_from_str(token(key.opening_loc), [builder.string_internal([key.unescaped, srange(key.value_loc)])], token(key.closing_loc))
        end
      else
        builder.match_hash_var_from_str(token(key.opening_loc), visit_all(key.parts), token(key.closing_loc))
      end
    else
      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

      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?
    builder.pair_keyword([key.unescaped, srange(key.location)], visit(node.value))
  else
    parts =
      if key.is_a?(SymbolNode)
        [builder.string_internal([key.unescaped, srange(key.value_loc)])]
      else
        visit_all(key.parts)
      end

    builder.pair_quoted(token(key.opening_loc), parts, token(key.closing_loc), visit(node.value))
  end
end

#visit_assoc_splat_node(node)

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

^^

{ **foo }

^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 182


def visit_assoc_splat_node(node)
  if in_pattern
    builder.match_rest(token(node.operator_loc), token(node.value&.location))
  elsif node.value.nil? && forwarding.include?(:**)
    builder.forwarded_kwrestarg(token(node.operator_loc))
  else
    builder.kwsplat(token(node.operator_loc), visit(node.value))
  end
end

#visit_back_reference_read_node(node)

$+ ^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 194


def visit_back_reference_read_node(node)
  builder.back_ref(token(node.location))
end

#visit_begin_node(node)

begin end ^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 200


def visit_begin_node(node)
  rescue_bodies = []

  if (rescue_clause = node.rescue_clause)
    begin
      find_start_offset = (rescue_clause.reference&.location || rescue_clause.exceptions.last&.location || rescue_clause.keyword_loc).end_offset
      find_end_offset = (
        rescue_clause.statements&.location&.start_offset ||
        rescue_clause.subsequent&.location&.start_offset ||
        node.else_clause&.location&.start_offset ||
        node.ensure_clause&.location&.start_offset ||
        node.end_keyword_loc&.start_offset ||
        find_start_offset + 1
      )

      rescue_bodies << builder.rescue_body(
        token(rescue_clause.keyword_loc),
        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, ";"),
        visit(rescue_clause.statements)
      )
    end until (rescue_clause = rescue_clause.subsequent).nil?
  end

  begin_body =
    builder.begin_body(
      visit(node.statements),
      rescue_bodies,
      token(node.else_clause&.else_keyword_loc),
      visit(node.else_clause),
      token(node.ensure_clause&.ensure_keyword_loc),
      visit(node.ensure_clause&.statements)
    )

  if node.begin_keyword_loc
    builder.begin_keyword(token(node.begin_keyword_loc), begin_body, token(node.end_keyword_loc))
  else
    begin_body
  end
end

#visit_block(call, block) (private)

Visit a block node on a call.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2034


def visit_block(call, block)
  if block
    parameters = block.parameters
    implicit_parameters = parameters.is_a?(NumberedParametersNode) || parameters.is_a?(ItParametersNode)

    builder.block(
      call,
      token(block.opening_loc),
      if parameters.nil?
        builder.args(nil, [], nil, false)
      elsif implicit_parameters
        visit(parameters)
      else
        builder.args(
          token(parameters.opening_loc),
          if procarg0?(parameters.parameters)
            parameter = parameters.parameters.requireds.first
            visited = parameter.is_a?(RequiredParameterNode) ? visit(parameter) : parameter.accept(copy_compiler(in_destructure: true))
            [builder.procarg0(visited)].concat(visit_all(parameters.locals))
          else
            visit(parameters)
          end,
          token(parameters.closing_loc),
          false
        )
      end,
      visit(block.body),
      token(block.closing_loc)
    )
  else
    call
  end
end

#visit_block_argument_node(node)

foo(&bar)

^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 245


def visit_block_argument_node(node)
  builder.block_pass(token(node.operator_loc), visit(node.expression))
end

#visit_block_local_variable_node(node)

foo { |; bar| }

^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 251


def visit_block_local_variable_node(node)
  builder.shadowarg(token(node.location))
end

#visit_block_node(node)

A block on a keyword or method call.

Raises:

(CompilationError)

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 256


def visit_block_node(node)
  raise CompilationError, "Cannot directly compile block nodes"
end

#visit_block_parameter_node(node)

def foo(&bar); end

^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 262


def visit_block_parameter_node(node)
  builder.blockarg(token(node.operator_loc), token(node.name_loc))
end

#visit_block_parameters_node(node)

A block’s parameters.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 267


def visit_block_parameters_node(node)
  [*visit(node.parameters)].concat(visit_all(node.locals))
end

#visit_break_node(node)

break ^^^^^

break foo ^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 276


def visit_break_node(node)
  builder.keyword_cmd(:break, token(node.keyword_loc), nil, visit(node.arguments) || [], nil)
end

#visit_call_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 381


def visit_call_and_write_node(node)
  call_operator_loc = node.call_operator_loc

  builder.op_assign(
    builder.call_method(
      visit(node.receiver),
      call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
      node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
      nil,
      [],
      nil
    ),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_call_node(node)

foo ^^^

foo.bar ^^^^^^^

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 288


def visit_call_node(node)
  name = node.name
  arguments = node.arguments&.arguments || []
  block = node.block

  if block.is_a?(BlockArgumentNode)
    arguments = [*arguments, block]
    block = nil
  end

  if node.call_operator_loc.nil?
    case name
    when :-@
      case (receiver = node.receiver).type
      when :integer_node, :float_node, :rational_node, :imaginary_node
        return visit(numeric_negate(node.message_loc, receiver))
      end
    when :!
      return visit_block(builder.not_op(token(node.message_loc), token(node.opening_loc), visit(node.receiver), token(node.closing_loc)), block)
    when :=~
      if (receiver = node.receiver).is_a?(RegularExpressionNode)
        return builder.match_op(visit(receiver), token(node.message_loc), visit(node.arguments.arguments.first))
      end
    when :[]
      return visit_block(builder.index(visit(node.receiver), token(node.opening_loc), visit_all(arguments), token(node.closing_loc)), block)
    when :[]=
      if node.message != "[]=" && node.arguments && block.nil? && !node.safe_navigation?
        arguments = node.arguments.arguments[...-1]
        arguments << node.block if node.block

        return visit_block(
          builder.assign(
            builder.index_asgn(
              visit(node.receiver),
              token(node.opening_loc),
              visit_all(arguments),
              token(node.closing_loc),
            ),
            srange_find(node.message_loc.end_offset, node.arguments.arguments.last.location.start_offset, "="),
            visit(node.arguments.arguments.last)
          ),
          block
        )
      end
    end
  end

  message_loc = node.message_loc
  call_operator_loc = node.call_operator_loc
  call_operator = [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)] if call_operator_loc

  visit_block(
    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, "="),
        visit(node.arguments.arguments.last)
      )
    else
      builder.call_method(
        visit(node.receiver),
        call_operator,
        message_loc ? [node.name, srange(message_loc)] : nil,
        token(node.opening_loc),
        visit_all(arguments),
        token(node.closing_loc)
      )
    end,
    block
  )
end

#visit_call_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 362


def visit_call_operator_write_node(node)
  call_operator_loc = node.call_operator_loc

  builder.op_assign(
    builder.call_method(
      visit(node.receiver),
      call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
      node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
      nil,
      [],
      nil
    ),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_call_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 400


def visit_call_or_write_node(node)
  call_operator_loc = node.call_operator_loc

  builder.op_assign(
    builder.call_method(
      visit(node.receiver),
      call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
      node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
      nil,
      [],
      nil
    ),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_call_target_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 419


def visit_call_target_node(node)
  call_operator_loc = node.call_operator_loc

  builder.attr_asgn(
    visit(node.receiver),
    call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
    token(node.message_loc)
  )
end

#visit_capture_pattern_node(node)

foo => bar => baz

^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 431


def visit_capture_pattern_node(node)
  builder.match_as(visit(node.value), token(node.operator_loc), visit(node.target))
end

#visit_case_match_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 450


def visit_case_match_node(node)
  builder.case_match(
    token(node.case_keyword_loc),
    visit(node.predicate),
    visit_all(node.conditions),
    token(node.else_clause&.else_keyword_loc),
    visit(node.else_clause),
    token(node.end_keyword_loc)
  )
end

#visit_case_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 437


def visit_case_node(node)
  builder.case(
    token(node.case_keyword_loc),
    visit(node.predicate),
    visit_all(node.conditions),
    token(node.else_clause&.else_keyword_loc),
    visit(node.else_clause),
    token(node.end_keyword_loc)
  )
end

#visit_class_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 463


def visit_class_node(node)
  builder.def_class(
    token(node.class_keyword_loc),
    visit(node.constant_path),
    token(node.inheritance_operator_loc),
    visit(node.superclass),
    node.body&.accept(copy_compiler(forwarding: [])),
    token(node.end_keyword_loc)
  )
end

#visit_class_variable_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 502


def visit_class_variable_and_write_node(node)
  builder.op_assign(
    builder.assignable(builder.cvar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_class_variable_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 492


def visit_class_variable_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.cvar(token(node.name_loc))),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_class_variable_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 512


def visit_class_variable_or_write_node(node)
  builder.op_assign(
    builder.assignable(builder.cvar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_class_variable_read_node(node)

@@foo ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 476


def visit_class_variable_read_node(node)
  builder.cvar(token(node.location))
end

#visit_class_variable_target_node(node)

@@foo, = bar ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 522


def visit_class_variable_target_node(node)
  builder.assignable(builder.cvar(token(node.location)))
end

#visit_class_variable_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 482


def visit_class_variable_write_node(node)
  builder.assign(
    builder.assignable(builder.cvar(token(node.name_loc))),
    token(node.operator_loc),
    visit(node.value)
  )
end

#visit_constant_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 553


def visit_constant_and_write_node(node)
  builder.op_assign(
    builder.assignable(builder.const([node.name, srange(node.name_loc)])),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_constant_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 543


def visit_constant_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.const([node.name, srange(node.name_loc)])),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_constant_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 563


def visit_constant_or_write_node(node)
  builder.op_assign(
    builder.assignable(builder.const([node.name, srange(node.name_loc)])),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_constant_path_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 619


def visit_constant_path_and_write_node(node)
  builder.op_assign(
    builder.assignable(visit(node.target)),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_constant_path_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 579


def visit_constant_path_node(node)
  if node.parent.nil?
    builder.const_global(
      token(node.delimiter_loc),
      [node.name, srange(node.name_loc)]
    )
  else
    builder.const_fetch(
      visit(node.parent),
      token(node.delimiter_loc),
      [node.name, srange(node.name_loc)]
    )
  end
end

#visit_constant_path_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 609


def visit_constant_path_operator_write_node(node)
  builder.op_assign(
    builder.assignable(visit(node.target)),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_constant_path_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 629


def visit_constant_path_or_write_node(node)
  builder.op_assign(
    builder.assignable(visit(node.target)),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_constant_path_target_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 639


def visit_constant_path_target_node(node)
  builder.assignable(visit_constant_path_node(node))
end

#visit_constant_path_write_node(node)

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 599


def visit_constant_path_write_node(node)
  builder.assign(
    builder.assignable(visit(node.target)),
    token(node.operator_loc),
    visit(node.value)
  )
end

#visit_constant_read_node(node)

Foo ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 528


def visit_constant_read_node(node)
  builder.const([node.name, srange(node.location)])
end

#visit_constant_target_node(node)

Foo, = bar ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 573


def visit_constant_target_node(node)
  builder.assignable(builder.const([node.name, srange(node.location)]))
end

#visit_constant_write_node(node)

Foo = 1 ^^^^^^^

Foo, Bar = 1 ^^^ ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 537


def visit_constant_write_node(node)
  builder.assign(builder.assignable(builder.const([node.name, srange(node.name_loc)])), token(node.operator_loc), visit(node.value))
end

#visit_def_node(node)

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 648


def visit_def_node(node)
  if node.equal_loc
    if node.receiver
      builder.def_endless_singleton(
        token(node.def_keyword_loc),
        visit(node.receiver.is_a?(ParenthesesNode) ? node.receiver.body : node.receiver),
        token(node.operator_loc),
        token(node.name_loc),
        builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
        token(node.equal_loc),
        node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters)))
      )
    else
      builder.def_endless_method(
        token(node.def_keyword_loc),
        token(node.name_loc),
        builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
        token(node.equal_loc),
        node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters)))
      )
    end
  elsif node.receiver
    builder.def_singleton(
      token(node.def_keyword_loc),
      visit(node.receiver.is_a?(ParenthesesNode) ? node.receiver.body : node.receiver),
      token(node.operator_loc),
      token(node.name_loc),
      builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
      node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters))),
      token(node.end_keyword_loc)
    )
  else
    builder.def_method(
      token(node.def_keyword_loc),
      token(node.name_loc),
      builder.args(token(node.lparen_loc), visit(node.parameters) || [], token(node.rparen_loc), false),
      node.body&.accept(copy_compiler(forwarding: find_forwarding(node.parameters))),
      token(node.end_keyword_loc)
    )
  end
end

#visit_defined_node(node)

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 695


def visit_defined_node(node)
  # 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

#visit_else_node(node)

if foo then bar else baz end

^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 731


def visit_else_node(node)
  visit(node.statements)
end

#visit_embedded_statements_node(node)

“foo #bar”

^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 737


def visit_embedded_statements_node(node)
  builder.begin(
    token(node.opening_loc),
    visit(node.statements),
    token(node.closing_loc)
  )
end

#visit_embedded_variable_node(node)

“foo #@bar”

^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 747


def visit_embedded_variable_node(node)
  visit(node.variable)
end

#visit_ensure_node(node)

begin; foo; ensure; bar; end

^^^^^^^^^^^^

Raises:

(CompilationError)

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 753


def visit_ensure_node(node)
  raise CompilationError, "Cannot directly compile ensure nodes"
end

#visit_false_node(node)

false ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 759


def visit_false_node(node)
  builder.false(token(node.location))
end

#visit_find_pattern_node(node)

foo => [*, bar, *]

^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 765


def visit_find_pattern_node(node)
  elements = [node.left, *node.requireds, node.right]

  if node.constant
    builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.find_pattern(nil, visit_all(elements), nil), token(node.closing_loc))
  else
    builder.find_pattern(token(node.opening_loc), visit_all(elements), token(node.closing_loc))
  end
end

#visit_flip_flop_node(node)

Alias for #visit_range_node.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1541


alias visit_flip_flop_node visit_range_node

#visit_float_node(node)

1.0 ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 777


def visit_float_node(node)
  visit_numeric(node, builder.float([node.value, srange(node.location)]))
end

#visit_for_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 783


def visit_for_node(node)
  builder.for(
    token(node.for_keyword_loc),
    visit(node.index),
    token(node.in_keyword_loc),
    visit(node.collection),
    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, ";")
    end,
    visit(node.statements),
    token(node.end_keyword_loc)
  )
end

#visit_forwarding_arguments_node(node)

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

^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 801


def visit_forwarding_arguments_node(node)
  builder.forwarded_args(token(node.location))
end

#visit_forwarding_parameter_node(node)

def foo(…); end

^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 807


def visit_forwarding_parameter_node(node)
  builder.forward_arg(token(node.location))
end

#visit_forwarding_super_node(node)

super ^^^^^

super {} ^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 816


def visit_forwarding_super_node(node)
  visit_block(
    builder.keyword_cmd(
      :zsuper,
      ["super", srange_offsets(node.location.start_offset, node.location.start_offset + 5)]
    ),
    node.block
  )
end

#visit_global_variable_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 854


def visit_global_variable_and_write_node(node)
  builder.op_assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_global_variable_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 844


def visit_global_variable_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_global_variable_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 864


def visit_global_variable_or_write_node(node)
  builder.op_assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_global_variable_read_node(node)

$foo ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 828


def visit_global_variable_read_node(node)
  builder.gvar(token(node.location))
end

#visit_global_variable_target_node(node)

$foo, = bar ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 874


def visit_global_variable_target_node(node)
  builder.assignable(builder.gvar([node.slice, srange(node.location)]))
end

#visit_global_variable_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 834


def visit_global_variable_write_node(node)
  builder.assign(
    builder.assignable(builder.gvar(token(node.name_loc))),
    token(node.operator_loc),
    visit(node.value)
  )
end

#visit_hash_node(node)

{} ^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 880


def visit_hash_node(node)
  builder.associate(
    token(node.opening_loc),
    visit_all(node.elements),
    token(node.closing_loc)
  )
end

#visit_hash_pattern_node(node)

foo => {}

^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 890


def visit_hash_pattern_node(node)
  elements = [*node.elements, *node.rest]

  if node.constant
    builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.hash_pattern(nil, visit_all(elements), nil), token(node.closing_loc))
  else
    builder.hash_pattern(token(node.opening_loc), visit_all(elements), token(node.closing_loc))
  end
end

#visit_heredoc(node) (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2069


def visit_heredoc(node)
  children = Array.new
  indented = false

  # If this is a dedenting heredoc, then we need to insert the opening
  # content into the children as well.
  if node.opening.start_with?("<<~") && node.parts.length > 0 && !node.parts.first.is_a?(StringNode)
    location = node.parts.first.location
    location = location.copy(start_offset: location.start_offset - location.start_line_slice.bytesize)
    children << builder.string_internal(token(location))
    indented = true
  end

  node.parts.each do |part|
    pushing =
      if part.is_a?(StringNode) && part.content.include?("\n")
        string_nodes_from_line_continuations(part.unescaped, part.content, part.location.start_offset, node.opening)
      else
        [visit(part)]
      end

    pushing.each do |child|
      if child.type == :str && child.children.last == ""
        # nothing
      elsif child.type == :str && children.last && children.last.type == :str && !children.last.children.first.end_with?("\n")
        appendee = children[-1]

        location = appendee.loc
        location = location.with_expression(location.expression.join(child.loc.expression))

        children[-1] = appendee.updated(:str, ["#{appendee.children.first}#{child.children.first}"], location: location)
      else
        children << child
      end
    end
  end

  closing = node.closing
  closing_t = [closing.chomp, srange_offsets(node.closing_loc.start_offset, node.closing_loc.end_offset - (closing[/\s+$/]&.length || 0))]
  composed = yield children, closing_t

  composed = composed.updated(nil, children[1..-1]) if indented
  composed
end

#visit_if_node(node)

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

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 908


def visit_if_node(node)
  if !node.if_keyword_loc
    builder.ternary(
      visit(node.predicate),
      token(node.then_keyword_loc),
      visit(node.statements),
      token(node.subsequent.else_keyword_loc),
      visit(node.subsequent)
    )
  elsif node.if_keyword_loc.start_offset == node.location.start_offset
    builder.condition(
      token(node.if_keyword_loc),
      visit(node.predicate),
      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, ";")
      end,
      visit(node.statements),
      case node.subsequent
      when IfNode
        token(node.subsequent.if_keyword_loc)
      when ElseNode
        token(node.subsequent.else_keyword_loc)
      end,
      visit(node.subsequent),
      if node.if_keyword != "elsif"
        token(node.end_keyword_loc)
      end
    )
  else
    builder.condition_mod(
      visit(node.statements),
      visit(node.subsequent),
      token(node.if_keyword_loc),
      visit(node.predicate)
    )
  end
end

#visit_imaginary_node(node)

1i ^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 950


def visit_imaginary_node(node)
  visit_numeric(node, builder.complex([Complex(0, node.numeric.value), srange(node.location)]))
end

#visit_implicit_node(node)

{ foo: }

^^^^

Raises:

(CompilationError)

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 956


def visit_implicit_node(node)
  raise CompilationError, "Cannot directly compile implicit nodes"
end

#visit_implicit_rest_node(node)

foo { |bar,| }

Raises:

(CompilationError)

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 962


def visit_implicit_rest_node(node)
  raise CompilationError, "Cannot compile implicit rest nodes"
end

#visit_in_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 968


def visit_in_node(node)
  pattern = nil
  guard = nil

  case node.pattern
  when IfNode
    pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
    guard = builder.if_guard(token(node.pattern.if_keyword_loc), visit(node.pattern.predicate))
  when UnlessNode
    pattern = within_pattern { |compiler| node.pattern.statements.accept(compiler) }
    guard = builder.unless_guard(token(node.pattern.keyword_loc), visit(node.pattern.predicate))
  else
    pattern = within_pattern { |compiler| node.pattern.accept(compiler) }
  end

  builder.in_pattern(
    token(node.in_loc),
    pattern,
    guard,
    if (then_loc = node.then_loc)
      token(then_loc)
    else
      srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset, ";")
    end,
    visit(node.statements)
  )
end

#visit_index_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1016


def visit_index_and_write_node(node)
  arguments = node.arguments&.arguments || []
  arguments << node.block if node.block

  builder.op_assign(
    builder.index(
      visit(node.receiver),
      token(node.opening_loc),
      visit_all(arguments),
      token(node.closing_loc)
    ),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_index_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 998


def visit_index_operator_write_node(node)
  arguments = node.arguments&.arguments || []
  arguments << node.block if node.block

  builder.op_assign(
    builder.index(
      visit(node.receiver),
      token(node.opening_loc),
      visit_all(arguments),
      token(node.closing_loc)
    ),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_index_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1034


def visit_index_or_write_node(node)
  arguments = node.arguments&.arguments || []
  arguments << node.block if node.block

  builder.op_assign(
    builder.index(
      visit(node.receiver),
      token(node.opening_loc),
      visit_all(arguments),
      token(node.closing_loc)
    ),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_index_target_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1052


def visit_index_target_node(node)
  builder.index_asgn(
    visit(node.receiver),
    token(node.opening_loc),
    visit_all(node.arguments&.arguments || []),
    token(node.closing_loc),
  )
end

#visit_instance_variable_and_write_node(node)

^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1089


def visit_instance_variable_and_write_node(node)
  builder.op_assign(
    builder.assignable(builder.ivar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_instance_variable_operator_write_node(node)

^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1079


def visit_instance_variable_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.ivar(token(node.name_loc))),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_instance_variable_or_write_node(node)

^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1099


def visit_instance_variable_or_write_node(node)
  builder.op_assign(
    builder.assignable(builder.ivar(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_instance_variable_read_node(node)

^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1063


def visit_instance_variable_read_node(node)
  builder.ivar(token(node.location))
end

#visit_instance_variable_target_node(node)

@foo, = bar ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1109


def visit_instance_variable_target_node(node)
  builder.assignable(builder.ivar(token(node.location)))
end

#visit_instance_variable_write_node(node)

^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1069


def visit_instance_variable_write_node(node)
  builder.assign(
    builder.assignable(builder.ivar(token(node.name_loc))),
    token(node.operator_loc),
    visit(node.value)
  )
end

#visit_integer_node(node)

1 ^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1115


def visit_integer_node(node)
  visit_numeric(node, builder.integer([node.value, srange(node.location)]))
end

#visit_interpolated_match_last_line_node(node)

Alias for #visit_interpolated_regular_expression_node.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1132


alias visit_interpolated_match_last_line_node visit_interpolated_regular_expression_node

#visit_interpolated_regular_expression_node(node) Also known as: #visit_interpolated_match_last_line_node

/foo #bar/ ^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1121


def visit_interpolated_regular_expression_node(node)
  builder.regexp_compose(
    token(node.opening_loc),
    string_nodes_from_interpolation(node, node.opening),
    [node.closing[0], srange_offsets(node.closing_loc.start_offset, node.closing_loc.start_offset + 1)],
    builder.regexp_options([node.closing[1..], srange_offsets(node.closing_loc.start_offset + 1, node.closing_loc.end_offset)])
  )
end

#visit_interpolated_string_node(node)

“foo #bar” ^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1136


def visit_interpolated_string_node(node)
  if node.heredoc?
    return visit_heredoc(node) { |children, closing| builder.string_compose(token(node.opening_loc), children, closing) }
  end

  builder.string_compose(
    token(node.opening_loc),
    string_nodes_from_interpolation(node, node.opening),
    token(node.closing_loc)
  )
end

#visit_interpolated_symbol_node(node)

:“foo #bar” ^^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1150


def visit_interpolated_symbol_node(node)
  builder.symbol_compose(
    token(node.opening_loc),
    string_nodes_from_interpolation(node, node.opening),
    token(node.closing_loc)
  )
end

#visit_interpolated_x_string_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1160


def visit_interpolated_x_string_node(node)
  if node.heredoc?
    return visit_heredoc(node) { |children, closing| builder.xstring_compose(token(node.opening_loc), children, closing) }
  end

  builder.xstring_compose(
    token(node.opening_loc),
    string_nodes_from_interpolation(node, node.opening),
    token(node.closing_loc)
  )
end

#visit_it_local_variable_read_node(node)

-> { it }

^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1174


def visit_it_local_variable_read_node(node)
  builder.ident([:it, srange(node.location)]).updated(:lvar)
end

#visit_it_parameters_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1180


def visit_it_parameters_node(node)
  # FIXME: The builder _should_ always be a subclass of the prism builder.
  # Currently RuboCop passes in its own builder that always inherits from the
  # parser builder (which is lacking the `itarg` method). Once rubocop-ast
  # opts in to use the custom prism builder a warning can be emitted when
  # it is not the expected class, and eventually raise.
  # https://github.com/rubocop/rubocop-ast/pull/354
  if builder.is_a?(Translation::Parser::Builder)
    builder.itarg
  else
    builder.args(nil, [], nil, false)
  end
end

#visit_keyword_hash_node(node)

foo(bar: baz)

^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1196


def visit_keyword_hash_node(node)
  builder.associate(nil, visit_all(node.elements), nil)
end

#visit_keyword_rest_parameter_node(node)

def foo(**bar); end

^^^^^

def foo(**); end

^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1205


def visit_keyword_rest_parameter_node(node)
  builder.kwrestarg(
    token(node.operator_loc),
    node.name ? [node.name, srange(node.name_loc)] : nil
  )
end

#visit_lambda_node(node)

-> {} ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1214


def visit_lambda_node(node)
  parameters = node.parameters
  implicit_parameters = parameters.is_a?(NumberedParametersNode) || parameters.is_a?(ItParametersNode)

  builder.block(
    builder.call_lambda(token(node.operator_loc)),
    [node.opening, srange(node.opening_loc)],
    if parameters.nil?
      builder.args(nil, [], nil, false)
    elsif implicit_parameters
      visit(node.parameters)
    else
      builder.args(
        token(node.parameters.opening_loc),
        visit(node.parameters),
        token(node.parameters.closing_loc),
        false
      )
    end,
    visit(node.body),
    [node.closing, srange(node.closing_loc)]
  )
end

#visit_local_variable_and_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1266


def visit_local_variable_and_write_node(node)
  builder.op_assign(
    builder.assignable(builder.ident(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_local_variable_operator_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1256


def visit_local_variable_operator_write_node(node)
  builder.op_assign(
    builder.assignable(builder.ident(token(node.name_loc))),
    [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
    visit(node.value)
  )
end

#visit_local_variable_or_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1276


def visit_local_variable_or_write_node(node)
  builder.op_assign(
    builder.assignable(builder.ident(token(node.name_loc))),
    [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end

#visit_local_variable_read_node(node)

foo ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1240


def visit_local_variable_read_node(node)
  builder.ident([node.name, srange(node.location)]).updated(:lvar)
end

#visit_local_variable_target_node(node)

foo, = bar ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1286


def visit_local_variable_target_node(node)
  if in_pattern
    builder.assignable(builder.match_var([node.name, srange(node.location)]))
  else
    builder.assignable(builder.ident(token(node.location)))
  end
end

#visit_local_variable_write_node(node)

foo = 1 ^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1246


def visit_local_variable_write_node(node)
  builder.assign(
    builder.assignable(builder.ident(token(node.name_loc))),
    token(node.operator_loc),
    visit(node.value)
  )
end

#visit_match_last_line_node(node)

Alias for #visit_regular_expression_node.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1577


alias visit_match_last_line_node visit_regular_expression_node

#visit_match_predicate_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1296


def visit_match_predicate_node(node)
  builder.match_pattern_p(
    visit(node.value),
    token(node.operator_loc),
    within_pattern { |compiler| node.pattern.accept(compiler) }
  )
end

#visit_match_required_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1306


def visit_match_required_node(node)
  builder.match_pattern(
    visit(node.value),
    token(node.operator_loc),
    within_pattern { |compiler| node.pattern.accept(compiler) }
  )
end

#visit_match_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1316


def visit_match_write_node(node)
  builder.match_op(
    visit(node.call.receiver),
    token(node.call.message_loc),
    visit(node.call.arguments.arguments.first)
  )
end

#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.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1327


def visit_missing_node(node)
  ::AST::Node.new(:missing, [], location: ::Parser::Source::Map.new(srange(node.location)))
end

#visit_module_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1333


def visit_module_node(node)
  builder.def_module(
    token(node.module_keyword_loc),
    visit(node.constant_path),
    node.body&.accept(copy_compiler(forwarding: [])),
    token(node.end_keyword_loc)
  )
end

#visit_multi_target_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1344


def visit_multi_target_node(node)
  builder.multi_lhs(
    token(node.lparen_loc),
    visit_all(multi_target_elements(node)),
    token(node.rparen_loc)
  )
end

#visit_multi_write_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1354


def visit_multi_write_node(node)
  elements = multi_target_elements(node)

  if elements.length == 1 && elements.first.is_a?(MultiTargetNode) && !node.rest
    elements = multi_target_elements(elements.first)
  end

  builder.multi_assign(
    builder.multi_lhs(
      token(node.lparen_loc),
      visit_all(elements),
      token(node.rparen_loc)
    ),
    token(node.operator_loc),
    visit(node.value)
  )
end

#visit_next_node(node)

next ^^^^

next foo ^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1377


def visit_next_node(node)
  builder.keyword_cmd(
    :next,
    token(node.keyword_loc),
    nil,
    visit(node.arguments) || [],
    nil
  )
end

#visit_nil_node(node)

nil ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1389


def visit_nil_node(node)
  builder.nil(token(node.location))
end

#visit_no_keywords_parameter_node(node)

def foo(**nil); end

^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1395


def visit_no_keywords_parameter_node(node)
  if in_pattern
    builder.match_nil_pattern(token(node.operator_loc), token(node.keyword_loc))
  else
    builder.kwnilarg(token(node.operator_loc), token(node.keyword_loc))
  end
end

#visit_numbered_parameters_node(node)

-> { _1 + _2 } ^^^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1405


def visit_numbered_parameters_node(node)
  builder.numargs(node.maximum)
end

#visit_numbered_reference_read_node(node)

$1 ^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1411


def visit_numbered_reference_read_node(node)
  builder.nth_ref([node.number, srange(node.location)])
end

#visit_numeric(node, value) (private)

Visit a numeric node and account for the optional sign.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2115


def visit_numeric(node, value)
  if (slice = node.slice).match?(/^[+-]/)
    builder.unary_num(
      [slice[0].to_sym, srange_offsets(node.location.start_offset, node.location.start_offset + 1)],
      value
    )
  else
    value
  end
end

#visit_optional_keyword_parameter_node(node)

def foo(bar: baz); end

^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1417


def visit_optional_keyword_parameter_node(node)
  builder.kwoptarg([node.name, srange(node.name_loc)], visit(node.value))
end

#visit_optional_parameter_node(node)

def foo(bar = 1); end

^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1423


def visit_optional_parameter_node(node)
  builder.optarg(token(node.name_loc), token(node.operator_loc), visit(node.value))
end

#visit_or_node(node)

a or b ^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1429


def visit_or_node(node)
  builder.logical_op(:or, visit(node.left), token(node.operator_loc), visit(node.right))
end

#visit_parameters_node(node)

def foo(bar, *baz); end

^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1435


def visit_parameters_node(node)
  params = []

  if node.requireds.any?
    node.requireds.each do |required|
      params <<
        if required.is_a?(RequiredParameterNode)
          visit(required)
        else
          required.accept(copy_compiler(in_destructure: true))
        end
    end
  end

  params.concat(visit_all(node.optionals)) if node.optionals.any?
  params << visit(node.rest) if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)

  if node.posts.any?
    node.posts.each do |post|
      params <<
        if post.is_a?(RequiredParameterNode)
          visit(post)
        else
          post.accept(copy_compiler(in_destructure: true))
        end
    end
  end

  params.concat(visit_all(node.keywords)) if node.keywords.any?
  params << visit(node.keyword_rest) if !node.keyword_rest.nil?
  params << visit(node.block) if !node.block.nil?
  params
end

#visit_parentheses_node(node)

() ^^

(1) ^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1474


def visit_parentheses_node(node)
  builder.begin(
    token(node.opening_loc),
    visit(node.body),
    token(node.closing_loc)
  )
end

#visit_pinned_expression_node(node)

foo => ^(bar)

^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1484


def visit_pinned_expression_node(node)
  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

#visit_pinned_variable_node(node)

foo = 1 and bar => ^foo

^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1492


def visit_pinned_variable_node(node)
  builder.pin(token(node.operator_loc), visit(node.variable))
end

#visit_post_execution_node(node)

END {}

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1497


def visit_post_execution_node(node)
  builder.postexe(
    token(node.keyword_loc),
    token(node.opening_loc),
    visit(node.statements),
    token(node.closing_loc)
  )
end

#visit_pre_execution_node(node)

BEGIN {}

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1507


def visit_pre_execution_node(node)
  builder.preexe(
    token(node.keyword_loc),
    token(node.opening_loc),
    visit(node.statements),
    token(node.closing_loc)
  )
end

#visit_program_node(node)

The top-level program node.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1517


def visit_program_node(node)
  visit(node.statements)
end

#visit_range_node(node) Also known as: #visit_flip_flop_node

0..5 ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1523


def visit_range_node(node)
  if node.exclude_end?
    builder.range_exclusive(
      visit(node.left),
      token(node.operator_loc),
      visit(node.right)
    )
  else
    builder.range_inclusive(
      visit(node.left),
      token(node.operator_loc),
      visit(node.right)
    )
  end
end

#visit_rational_node(node)

1r ^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1545


def visit_rational_node(node)
  visit_numeric(node, builder.rational([node.value, srange(node.location)]))
end

#visit_redo_node(node)

redo ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1551


def visit_redo_node(node)
  builder.keyword_cmd(:redo, token(node.location))
end

#visit_regular_expression_node(node) Also known as: #visit_match_last_line_node

/foo/ ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1557


def visit_regular_expression_node(node)
  parts =
    if node.content == ""
      []
    elsif node.content.include?("\n")
      string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
    else
      [builder.string_internal([node.unescaped, srange(node.content_loc)])]
    end

  builder.regexp_compose(
    token(node.opening_loc),
    parts,
    [node.closing[0], srange_offsets(node.closing_loc.start_offset, node.closing_loc.start_offset + 1)],
    builder.regexp_options([node.closing[1..], srange_offsets(node.closing_loc.start_offset + 1, node.closing_loc.end_offset)])
  )
end

#visit_required_keyword_parameter_node(node)

def foo(bar:); end

^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1581


def visit_required_keyword_parameter_node(node)
  builder.kwarg([node.name, srange(node.name_loc)])
end

#visit_required_parameter_node(node)

def foo(bar); end

^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1587


def visit_required_parameter_node(node)
  builder.arg(token(node.location))
end

#visit_rescue_modifier_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1593


def visit_rescue_modifier_node(node)
  builder.begin_body(
    visit(node.expression),
    [
      builder.rescue_body(
        token(node.keyword_loc),
        nil,
        nil,
        nil,
        nil,
        visit(node.rescue_expression)
      )
    ]
  )
end

#visit_rescue_node(node)

begin; rescue; end

^^^^^^^

Raises:

(CompilationError)

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1611


def visit_rescue_node(node)
  raise CompilationError, "Cannot directly compile rescue nodes"
end

#visit_rest_parameter_node(node)

def foo(*bar); end

^^^^

def foo(*); end

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1620


def visit_rest_parameter_node(node)
  builder.restarg(token(node.operator_loc), token(node.name_loc))
end

#visit_retry_node(node)

retry ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1626


def visit_retry_node(node)
  builder.keyword_cmd(:retry, token(node.location))
end

#visit_return_node(node)

return ^^^^^^

return 1 ^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1635


def visit_return_node(node)
  builder.keyword_cmd(
    :return,
    token(node.keyword_loc),
    nil,
    visit(node.arguments) || [],
    nil
  )
end

#visit_self_node(node)

self ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1647


def visit_self_node(node)
  builder.self(token(node.location))
end

#visit_shareable_constant_node(node)

A shareable constant.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1652


def visit_shareable_constant_node(node)
  visit(node.write)
end

#visit_singleton_class_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1658


def visit_singleton_class_node(node)
  builder.def_sclass(
    token(node.class_keyword_loc),
    token(node.operator_loc),
    visit(node.expression),
    node.body&.accept(copy_compiler(forwarding: [])),
    token(node.end_keyword_loc)
  )
end

#visit_source_encoding_node(node)

__ENCODING__ ^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1670


def visit_source_encoding_node(node)
  builder.accessible(builder.__ENCODING__(token(node.location)))
end

#visit_source_file_node(node)

__FILE__ ^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1676


def visit_source_file_node(node)
  builder.accessible(builder.__FILE__(token(node.location)))
end

#visit_source_line_node(node)

__LINE__ ^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1682


def visit_source_line_node(node)
  builder.accessible(builder.__LINE__(token(node.location)))
end

#visit_splat_node(node)

foo(*bar)

^^^^

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

^^^^

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1694


def visit_splat_node(node)
  if node.expression.nil? && forwarding.include?(:*)
    builder.forwarded_restarg(token(node.operator_loc))
  elsif in_destructure
    builder.restarg(token(node.operator_loc), token(node.expression&.location))
  elsif in_pattern
    builder.match_rest(token(node.operator_loc), token(node.expression&.location))
  else
    builder.splat(token(node.operator_loc), visit(node.expression))
  end
end

#visit_statements_node(node)

A list of statements.

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1707


def visit_statements_node(node)
  builder.compstmt(visit_all(node.body))
end

#visit_string_node(node)

“foo” ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1713


def visit_string_node(node)
  if node.heredoc?
    visit_heredoc(node.to_interpolated) { |children, closing| builder.string_compose(token(node.opening_loc), children, closing) }
  elsif node.opening == "?"
    builder.character([node.unescaped, srange(node.location)])
  elsif node.opening&.start_with?("%") && node.unescaped.empty?
    builder.string_compose(token(node.opening_loc), [], token(node.closing_loc))
  else
    parts =
      if node.content.include?("\n")
        string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
      else
        [builder.string_internal([node.unescaped, srange(node.content_loc)])]
      end

    builder.string_compose(
      token(node.opening_loc),
      parts,
      token(node.closing_loc)
    )
  end
end

#visit_super_node(node)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1738


def visit_super_node(node)
  arguments = node.arguments&.arguments || []
  block = node.block

  if block.is_a?(BlockArgumentNode)
    arguments = [*arguments, block]
    block = nil
  end

  visit_block(
    builder.keyword_cmd(
      :super,
      token(node.keyword_loc),
      token(node.lparen_loc),
      visit_all(arguments),
      token(node.rparen_loc)
    ),
    block
  )
end

#visit_symbol_node(node)

:foo ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1761


def visit_symbol_node(node)
  if node.closing_loc.nil?
    if node.opening_loc.nil?
      builder.symbol_internal([node.unescaped, srange(node.location)])
    else
      builder.symbol([node.unescaped, srange(node.location)])
    end
  else
    parts =
      if node.value == ""
        []
      elsif node.value.include?("\n")
        string_nodes_from_line_continuations(node.unescaped, node.value, node.value_loc.start_offset, node.opening)
      else
        [builder.string_internal([node.unescaped, srange(node.value_loc)])]
      end

    builder.symbol_compose(
      token(node.opening_loc),
      parts,
      token(node.closing_loc)
    )
  end
end

#visit_true_node(node)

true ^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1788


def visit_true_node(node)
  builder.true(token(node.location))
end

#visit_undef_node(node)

undef foo ^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1794


def visit_undef_node(node)
  builder.undef_method(token(node.keyword_loc), visit_all(node.names))
end

#visit_unless_node(node)

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1803


def visit_unless_node(node)
  if node.keyword_loc.start_offset == node.location.start_offset
    builder.condition(
      token(node.keyword_loc),
      visit(node.predicate),
      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, ";")
      end,
      visit(node.else_clause),
      token(node.else_clause&.else_keyword_loc),
      visit(node.statements),
      token(node.end_keyword_loc)
    )
  else
    builder.condition_mod(
      visit(node.else_clause),
      visit(node.statements),
      token(node.keyword_loc),
      visit(node.predicate)
    )
  end
end

#visit_until_node(node)

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1833


def visit_until_node(node)
  if node.location.start_offset == node.keyword_loc.start_offset
    builder.loop(
      :until,
      token(node.keyword_loc),
      visit(node.predicate),
      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, ";")
      end,
      visit(node.statements),
      token(node.closing_loc)
    )
  else
    builder.loop_mod(
      :until,
      visit(node.statements),
      token(node.keyword_loc),
      visit(node.predicate)
    )
  end
end

#visit_when_node(node)

case foo; when bar; end

^^^^^^^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1859


def visit_when_node(node)
  builder.when(
    token(node.keyword_loc),
    visit_all(node.conditions),
    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, ";")
    end,
    visit(node.statements)
  )
end

#visit_while_node(node)

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

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1877


def visit_while_node(node)
  if node.location.start_offset == node.keyword_loc.start_offset
    builder.loop(
      :while,
      token(node.keyword_loc),
      visit(node.predicate),
      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, ";")
      end,
      visit(node.statements),
      token(node.closing_loc)
    )
  else
    builder.loop_mod(
      :while,
      visit(node.statements),
      token(node.keyword_loc),
      visit(node.predicate)
    )
  end
end

#visit_x_string_node(node)

foo ^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1903


def visit_x_string_node(node)
  if node.heredoc?
    return visit_heredoc(node.to_interpolated) { |children, closing| builder.xstring_compose(token(node.opening_loc), children, closing) }
  end

  parts =
    if node.content == ""
      []
    elsif node.content.include?("\n")
      string_nodes_from_line_continuations(node.unescaped, node.content, node.content_loc.start_offset, node.opening)
    else
      [builder.string_internal([node.unescaped, srange(node.content_loc)])]
    end

  builder.xstring_compose(
    token(node.opening_loc),
    parts,
    token(node.closing_loc)
  )
end

#visit_yield_node(node)

yield ^^^^^

yield 1 ^^^^^^^

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 1929


def visit_yield_node(node)
  builder.keyword_cmd(
    :yield,
    token(node.keyword_loc),
    token(node.lparen_loc),
    visit(node.arguments) || [],
    token(node.rparen_loc)
  )
end

#within_pattern (private)

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

[ GitHub ]

# File 'lib/prism/translation/parser/compiler.rb', line 2127


def within_pattern
  begin
    parser.pattern_variables.push
    yield copy_compiler(in_pattern: true)
  ensure
    parser.pattern_variables.pop
  end
end

Class: Prism::Translation::Parser::Compiler

Overview

Constant Summary

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

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

Instance Attribute Details

#builder (readonly)

#forwarding (readonly)

#in_destructure (readonly)

#in_pattern (readonly)

#offset_cache (readonly)

#parser (readonly)

#source_buffer (readonly)

Instance Method Details

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

#find_forwarding(node) (private)

#multi_target_elements(node) (private)

#numeric_negate(message_loc, receiver) (private)

#procarg0?(parameters) ⇒ Boolean (private)

#srange(location) (private)

#srange_find(start_offset, end_offset, character) (private)

#srange_offsets(start_offset, end_offset) (private)

#string_nodes_from_interpolation(node, opening) (private)

#string_nodes_from_line_continuations(unescaped, escaped, start_offset, opening) (private)

#token(location) (private)

#visit_alias_global_variable_node(node)

#visit_alias_method_node(node)

#visit_alternation_pattern_node(node)

#visit_and_node(node)

#visit_arguments_node(node)

#visit_array_node(node)

#visit_array_pattern_node(node)

#visit_assoc_node(node)

#visit_assoc_splat_node(node)

#visit_back_reference_read_node(node)

#visit_begin_node(node)

#visit_block(call, block) (private)

#visit_block_argument_node(node)

#visit_block_local_variable_node(node)

#visit_block_node(node)

#visit_block_parameter_node(node)

#visit_block_parameters_node(node)

#visit_break_node(node)

#visit_call_and_write_node(node)

#visit_call_node(node)

#visit_call_operator_write_node(node)

#visit_call_or_write_node(node)

#visit_call_target_node(node)

#visit_capture_pattern_node(node)

#visit_case_match_node(node)

#visit_case_node(node)

#visit_class_node(node)

#visit_class_variable_and_write_node(node)

#visit_class_variable_operator_write_node(node)

#visit_class_variable_or_write_node(node)

#visit_class_variable_read_node(node)

#visit_class_variable_target_node(node)

#visit_class_variable_write_node(node)

#visit_constant_and_write_node(node)

#visit_constant_operator_write_node(node)

#visit_constant_or_write_node(node)

#visit_constant_path_and_write_node(node)

#visit_constant_path_node(node)

#visit_constant_path_operator_write_node(node)

#visit_constant_path_or_write_node(node)

#visit_constant_path_target_node(node)

#visit_constant_path_write_node(node)

#visit_constant_read_node(node)

#visit_constant_target_node(node)

#visit_constant_write_node(node)

#visit_def_node(node)

#visit_defined_node(node)

#visit_else_node(node)

#visit_embedded_statements_node(node)

#visit_embedded_variable_node(node)

#visit_ensure_node(node)

#visit_false_node(node)

.new(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false) ⇒ `Compiler`

#procarg0?(parameters) ⇒ `Boolean` (private)