class Prism::Translation::Parser::Compiler

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

Constants

Range

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

Attributes

builder[R]

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

forwarding[R]

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

in_destructure[R]

Whether or not the current node is in a destructure.

in_pattern[R]

Whether or not the current node is in a pattern.

offset_cache[R]

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

parser[R]

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

source_buffer[R]

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

Public Class Methods

new(parser, offset_cache, forwarding: [], in_destructure: false, in_pattern: false) click to toggle source

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

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

Public Instance Methods

visit_alias_global_variable_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 58
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 52
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) click to toggle source

foo => bar | baz

^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 64
def visit_alternation_pattern_node(node)
  builder.match_alt(visit(node.left), token(node.operator_loc), visit(node.right))
end
visit_and_node(node) click to toggle source

a and b ^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 70
def visit_and_node(node)
  builder.logical_op(:and, visit(node.left), token(node.operator_loc), visit(node.right))
end
visit_arguments_node(node) click to toggle source

foo(bar)

^^^
# File lib/prism/translation/parser/compiler.rb, line 101
def visit_arguments_node(node)
  visit_all(node.arguments)
end
visit_array_node(node) click to toggle source

^^

# File lib/prism/translation/parser/compiler.rb, line 76
def visit_array_node(node)
  builder.array(token(node.opening_loc), visit_all(node.elements), token(node.closing_loc))
end
visit_array_pattern_node(node) click to toggle source

foo => [bar]

^^^^^
# File lib/prism/translation/parser/compiler.rb, line 82
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
    builder.const_pattern(visit(node.constant), token(node.opening_loc), builder.array_pattern(nil, visited, nil), token(node.closing_loc))
  else
    builder.array_pattern(token(node.opening_loc), visited, token(node.closing_loc))
  end
end
visit_assoc_node(node) click to toggle source

{ a: 1 }

^^^^
# File lib/prism/translation/parser/compiler.rb, line 107
def visit_assoc_node(node)
  if in_pattern
    if node.value.is_a?(ImplicitNode)
      if node.key.is_a?(SymbolNode)
        builder.match_hash_var([node.key.unescaped, srange(node.key.location)])
      else
        builder.match_hash_var_from_str(token(node.key.opening_loc), visit_all(node.key.parts), token(node.key.closing_loc))
      end
    else
      builder.pair_keyword([node.key.unescaped, srange(node.key.location)], visit(node.value))
    end
  elsif node.value.is_a?(ImplicitNode)
    builder.pair_label([node.key.unescaped, srange(node.key.location)])
  elsif node.operator_loc
    builder.pair(visit(node.key), token(node.operator_loc), visit(node.value))
  elsif node.key.is_a?(SymbolNode) && node.key.opening_loc.nil?
    builder.pair_keyword([node.key.unescaped, srange(node.key.location)], visit(node.value))
  else
    parts =
      if node.key.is_a?(SymbolNode)
        [builder.string_internal([node.key.unescaped, srange(node.key.value_loc)])]
      else
        visit_all(node.key.parts)
      end

    builder.pair_quoted(token(node.key.opening_loc), parts, token(node.key.closing_loc), visit(node.value))
  end
end
visit_assoc_splat_node(node) click to toggle source

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

^^

{ **foo }

^^^^^
# File lib/prism/translation/parser/compiler.rb, line 141
def visit_assoc_splat_node(node)
  if 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) click to toggle source

$+ ^^

# File lib/prism/translation/parser/compiler.rb, line 151
def visit_back_reference_read_node(node)
  builder.back_ref(token(node.location))
end
visit_begin_node(node) click to toggle source

begin end ^^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 157
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.consequent&.location&.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.consequent).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_argument_node(node) click to toggle source

foo(&bar)

^^^^
# File lib/prism/translation/parser/compiler.rb, line 195
def visit_block_argument_node(node)
  builder.block_pass(token(node.operator_loc), visit(node.expression))
end
visit_block_local_variable_node(node) click to toggle source

foo { |; bar| }

^^^
# File lib/prism/translation/parser/compiler.rb, line 201
def visit_block_local_variable_node(node)
  builder.shadowarg(token(node.location))
end
visit_block_node(node) click to toggle source

A block on a keyword or method call.

# File lib/prism/translation/parser/compiler.rb, line 206
def visit_block_node(node)
  raise CompilationError, "Cannot directly compile block nodes"
end
visit_block_parameter_node(node) click to toggle source

def foo(&bar); end

^^^^
# File lib/prism/translation/parser/compiler.rb, line 212
def visit_block_parameter_node(node)
  builder.blockarg(token(node.operator_loc), token(node.name_loc))
end
visit_block_parameters_node(node) click to toggle source

A block’s parameters.

# File lib/prism/translation/parser/compiler.rb, line 217
def visit_block_parameters_node(node)
  [*visit(node.parameters)].concat(visit_all(node.locals))
end
visit_break_node(node) click to toggle source

break ^^^^^

break foo ^^^^^^^^^

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

visit_call_node(node) click to toggle source

foo ^^^

foo.bar ^^^^^^^

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

# File lib/prism/translation/parser/compiler.rb, line 238
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 :[]
      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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 308
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.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end
visit_call_or_write_node(node)

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

visit_call_target_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 335
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) click to toggle source

foo => bar => baz

^^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 347
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 366
def visit_case_match_node(node)
  builder.case_match(
    token(node.case_keyword_loc),
    visit(node.predicate),
    visit_all(node.conditions),
    token(node.consequent&.else_keyword_loc),
    visit(node.consequent),
    token(node.end_keyword_loc)
  )
end
visit_case_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 353
def visit_case_node(node)
  builder.case(
    token(node.case_keyword_loc),
    visit(node.predicate),
    visit_all(node.conditions),
    token(node.consequent&.else_keyword_loc),
    visit(node.consequent),
    token(node.end_keyword_loc)
  )
end
visit_class_node(node) click to toggle source

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

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

visit_class_variable_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 411
def visit_class_variable_operator_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_or_write_node(node)

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

visit_class_variable_read_node(node) click to toggle source

@@foo ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 392
def visit_class_variable_read_node(node)
  builder.cvar(token(node.location))
end
visit_class_variable_target_node(node) click to toggle source

@@foo, = bar ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 429
def visit_class_variable_target_node(node)
  builder.assignable(builder.cvar(token(node.location)))
end
visit_class_variable_write_node(node) click to toggle source

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

@@foo, @@bar = 1 ^^^^^ ^^^^^

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

visit_constant_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 450
def visit_constant_operator_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_or_write_node(node)

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

visit_constant_path_and_write_node(node)

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

visit_constant_path_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 474
def visit_constant_path_node(node)
  if node.parent.nil?
    builder.const_global(
      token(node.delimiter_loc),
      [node.child.name, srange(node.child.location)]
    )
  else
    builder.const_fetch(
      visit(node.parent),
      token(node.delimiter_loc),
      [node.child.name, srange(node.child.location)]
    )
  end
end
visit_constant_path_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 504
def visit_constant_path_operator_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_or_write_node(node)

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

visit_constant_path_target_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 522
def visit_constant_path_target_node(node)
  builder.assignable(visit_constant_path_node(node))
end
visit_constant_path_write_node(node) click to toggle source

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

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

# File lib/prism/translation/parser/compiler.rb, line 494
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) click to toggle source

Foo ^^^

# File lib/prism/translation/parser/compiler.rb, line 435
def visit_constant_read_node(node)
  builder.const([node.name, srange(node.location)])
end
visit_constant_target_node(node) click to toggle source

Foo, = bar ^^^

# File lib/prism/translation/parser/compiler.rb, line 468
def visit_constant_target_node(node)
  builder.assignable(builder.const([node.name, srange(node.location)]))
end
visit_constant_write_node(node) click to toggle source

Foo = 1 ^^^^^^^

Foo, Bar = 1 ^^^ ^^^

# File lib/prism/translation/parser/compiler.rb, line 444
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) click to toggle source

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

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

# File lib/prism/translation/parser/compiler.rb, line 531
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) click to toggle source

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

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

# File lib/prism/translation/parser/compiler.rb, line 578
def visit_defined_node(node)
  builder.keyword_cmd(
    :defined?,
    token(node.keyword_loc),
    token(node.lparen_loc),
    [visit(node.value)],
    token(node.rparen_loc)
  )
end
visit_else_node(node) click to toggle source

if foo then bar else baz end

^^^^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 590
def visit_else_node(node)
  visit(node.statements)
end
visit_embedded_statements_node(node) click to toggle source

“foo #{bar}”

^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 596
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) click to toggle source

“foo #@bar”

^^^^^
# File lib/prism/translation/parser/compiler.rb, line 606
def visit_embedded_variable_node(node)
  visit(node.variable)
end
visit_ensure_node(node) click to toggle source

begin; foo; ensure; bar; end

^^^^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 612
def visit_ensure_node(node)
  raise CompilationError, "Cannot directly compile ensure nodes"
end
visit_false_node(node) click to toggle source

false ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 618
def visit_false_node(node)
  builder.false(token(node.location))
end
visit_find_pattern_node(node) click to toggle source

foo => [*, bar, *]

^^^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 624
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)

if foo .. bar; end

^^^^^^^^^^
Alias for: visit_range_node
visit_float_node(node) click to toggle source

1.0 ^^^

# File lib/prism/translation/parser/compiler.rb, line 636
def visit_float_node(node)
  visit_numeric(node, builder.float([node.value, srange(node.location)]))
end
visit_for_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 642
def visit_for_node(node)
  builder.for(
    token(node.for_keyword_loc),
    visit(node.index),
    token(node.in_keyword_loc),
    visit(node.collection),
    if node.do_keyword_loc
      token(node.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) click to toggle source

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

^^^
# File lib/prism/translation/parser/compiler.rb, line 660
def visit_forwarding_arguments_node(node)
  builder.forwarded_args(token(node.location))
end
visit_forwarding_parameter_node(node) click to toggle source

def foo(…); end

^^^
# File lib/prism/translation/parser/compiler.rb, line 666
def visit_forwarding_parameter_node(node)
  builder.forward_arg(token(node.location))
end
visit_forwarding_super_node(node) click to toggle source

super ^^^^^

super {} ^^^^^^^^

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

visit_global_variable_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 706
def visit_global_variable_operator_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_or_write_node(node)

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

visit_global_variable_read_node(node) click to toggle source

$foo ^^^^

# File lib/prism/translation/parser/compiler.rb, line 687
def visit_global_variable_read_node(node)
  builder.gvar(token(node.location))
end
visit_global_variable_target_node(node) click to toggle source

$foo, = bar ^^^^

# File lib/prism/translation/parser/compiler.rb, line 724
def visit_global_variable_target_node(node)
  builder.assignable(builder.gvar([node.slice, srange(node.location)]))
end
visit_global_variable_write_node(node) click to toggle source

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

$foo, $bar = 1 ^^^^ ^^^^

# File lib/prism/translation/parser/compiler.rb, line 696
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) click to toggle source

{} ^^

# File lib/prism/translation/parser/compiler.rb, line 730
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) click to toggle source

foo => {}

^^
# File lib/prism/translation/parser/compiler.rb, line 740
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_if_node(node) click to toggle source

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

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

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

# File lib/prism/translation/parser/compiler.rb, line 758
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.consequent.else_keyword_loc),
      visit(node.consequent)
    )
  elsif node.if_keyword_loc.start_offset == node.location.start_offset
    builder.condition(
      token(node.if_keyword_loc),
      visit(node.predicate),
      if node.then_keyword_loc
        token(node.then_keyword_loc)
      else
        srange_find(node.predicate.location.end_offset, (node.statements&.location || node.consequent&.location || node.end_keyword_loc).start_offset, [";"])
      end,
      visit(node.statements),
      case node.consequent
      when IfNode
        token(node.consequent.if_keyword_loc)
      when ElseNode
        token(node.consequent.else_keyword_loc)
      end,
      visit(node.consequent),
      if node.if_keyword != "elsif"
        token(node.end_keyword_loc)
      end
    )
  else
    builder.condition_mod(
      visit(node.statements),
      visit(node.consequent),
      token(node.if_keyword_loc),
      visit(node.predicate)
    )
  end
end
visit_imaginary_node(node) click to toggle source

1i

# File lib/prism/translation/parser/compiler.rb, line 799
def visit_imaginary_node(node)
  visit_numeric(node, builder.complex([imaginary_value(node), srange(node.location)]))
end
visit_implicit_node(node) click to toggle source

{ foo: }

^^^^
# File lib/prism/translation/parser/compiler.rb, line 805
def visit_implicit_node(node)
  raise CompilationError, "Cannot directly compile implicit nodes"
end
visit_implicit_rest_node(node) click to toggle source

foo { |bar,| }

^
# File lib/prism/translation/parser/compiler.rb, line 811
def visit_implicit_rest_node(node)
  raise CompilationError, "Cannot compile implicit rest nodes"
end
visit_in_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 817
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,
    srange_find(node.pattern.location.end_offset, node.statements&.location&.start_offset || node.location.end_offset, [";", "then"]),
    visit(node.statements)
  )
end
visit_index_and_write_node(node)

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

visit_index_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 843
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.operator_loc.slice.chomp("="), srange(node.operator_loc)],
    visit(node.value)
  )
end
visit_index_or_write_node(node)

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

visit_index_target_node(node) click to toggle source

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

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

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

visit_instance_variable_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 899
def visit_instance_variable_operator_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_or_write_node(node)

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

visit_instance_variable_read_node(node) click to toggle source

@foo ^^^^

# File lib/prism/translation/parser/compiler.rb, line 880
def visit_instance_variable_read_node(node)
  builder.ivar(token(node.location))
end
visit_instance_variable_target_node(node) click to toggle source

@foo, = bar ^^^^

# File lib/prism/translation/parser/compiler.rb, line 917
def visit_instance_variable_target_node(node)
  builder.assignable(builder.ivar(token(node.location)))
end
visit_instance_variable_write_node(node) click to toggle source

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

@foo, @bar = 1 ^^^^ ^^^^

# File lib/prism/translation/parser/compiler.rb, line 889
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) click to toggle source

1 ^

# File lib/prism/translation/parser/compiler.rb, line 923
def visit_integer_node(node)
  visit_numeric(node, builder.integer([node.value, srange(node.location)]))
end
visit_interpolated_match_last_line_node(node)

if /foo #{bar}/ then end

^^^^^^^^^^^^
visit_interpolated_regular_expression_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 929
def visit_interpolated_regular_expression_node(node)
  builder.regexp_compose(
    token(node.opening_loc),
    visit_all(node.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_interpolated_string_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 944
def visit_interpolated_string_node(node)
  if node.heredoc?
    children, closing = visit_heredoc(node)
    builder.string_compose(token(node.opening_loc), children, closing)
  else
    builder.string_compose(
      token(node.opening_loc),
      visit_all(node.parts),
      token(node.closing_loc)
    )
  end
end
visit_interpolated_symbol_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 959
def visit_interpolated_symbol_node(node)
  builder.symbol_compose(
    token(node.opening_loc),
    visit_all(node.parts),
    token(node.closing_loc)
  )
end
visit_interpolated_x_string_node(node) click to toggle source

‘foo #{bar}` ^^^^^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 969
def visit_interpolated_x_string_node(node)
  if node.heredoc?
    children, closing = visit_heredoc(node)
    builder.xstring_compose(token(node.opening_loc), children, closing)
  else
    builder.xstring_compose(
      token(node.opening_loc),
      visit_all(node.parts),
      token(node.closing_loc)
    )
  end
end
visit_keyword_hash_node(node) click to toggle source

foo(bar: baz)

^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 984
def visit_keyword_hash_node(node)
  builder.associate(nil, visit_all(node.elements), nil)
end
visit_keyword_rest_parameter_node(node) click to toggle source

def foo(**bar); end

^^^^^

def foo(**); end

^^
# File lib/prism/translation/parser/compiler.rb, line 993
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) click to toggle source

-> {}

# File lib/prism/translation/parser/compiler.rb, line 1001
def visit_lambda_node(node)
  parameters = node.parameters

  builder.block(
    builder.call_lambda(token(node.operator_loc)),
    [node.opening, srange(node.opening_loc)],
    if parameters.nil?
      builder.args(nil, [], nil, false)
    elsif node.parameters.is_a?(NumberedParametersNode)
      visit(node.parameters)
    else
      builder.args(
        token(node.parameters.opening_loc),
        visit(node.parameters),
        token(node.parameters.closing_loc),
        false
      )
    end,
    node.body&.accept(copy_compiler(forwarding: parameters.is_a?(NumberedParametersNode) ? [] : find_forwarding(parameters&.parameters))),
    [node.closing, srange(node.closing_loc)]
  )
end
visit_local_variable_and_write_node(node)

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

visit_local_variable_operator_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1045
def visit_local_variable_operator_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_or_write_node(node)

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

visit_local_variable_read_node(node) click to toggle source

foo ^^^

# File lib/prism/translation/parser/compiler.rb, line 1026
def visit_local_variable_read_node(node)
  builder.ident([node.name, srange(node.location)]).updated(:lvar)
end
visit_local_variable_target_node(node) click to toggle source

foo, = bar ^^^

# File lib/prism/translation/parser/compiler.rb, line 1063
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) click to toggle source

foo = 1 ^^^^^^^

foo, bar = 1 ^^^ ^^^

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

if /foo/ then end

^^^^^
visit_match_predicate_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1073
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1083
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1093
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) click to toggle source

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.

# File lib/prism/translation/parser/compiler.rb, line 1104
def visit_missing_node(node)
  ::AST::Node.new(:missing, [], location: ::Parser::Source::Map.new(srange(node.location)))
end
visit_module_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1110
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1121
def visit_multi_target_node(node)
  elements = [*node.lefts]
  elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
  elements.concat(node.rights)

  builder.multi_lhs(
    token(node.lparen_loc),
    visit_all(elements),
    token(node.rparen_loc)
  )
end
visit_multi_write_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1135
def visit_multi_write_node(node)
  elements = [*node.lefts]
  elements << node.rest if !node.rest.nil? && !node.rest.is_a?(ImplicitRestNode)
  elements.concat(node.rights)

  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) click to toggle source

next ^^^^

next foo ^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1156
def visit_next_node(node)
  builder.keyword_cmd(
    :next,
    token(node.keyword_loc),
    nil,
    visit(node.arguments) || [],
    nil
  )
end
visit_nil_node(node) click to toggle source

nil ^^^

# File lib/prism/translation/parser/compiler.rb, line 1168
def visit_nil_node(node)
  builder.nil(token(node.location))
end
visit_no_keywords_parameter_node(node) click to toggle source

def foo(**nil); end

^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1174
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1184
def visit_numbered_parameters_node(node)
  builder.numargs(node.maximum)
end
visit_numbered_reference_read_node(node) click to toggle source

$1 ^^

# File lib/prism/translation/parser/compiler.rb, line 1190
def visit_numbered_reference_read_node(node)
  builder.nth_ref([node.number, srange(node.location)])
end
visit_optional_keyword_parameter_node(node) click to toggle source

def foo(bar: baz); end

^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1196
def visit_optional_keyword_parameter_node(node)
  builder.kwoptarg([node.name, srange(node.name_loc)], visit(node.value))
end
visit_optional_parameter_node(node) click to toggle source

def foo(bar = 1); end

^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1202
def visit_optional_parameter_node(node)
  builder.optarg(token(node.name_loc), token(node.operator_loc), visit(node.value))
end
visit_or_node(node) click to toggle source

a or b ^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1208
def visit_or_node(node)
  builder.logical_op(:or, visit(node.left), token(node.operator_loc), visit(node.right))
end
visit_parameters_node(node) click to toggle source

def foo(bar, *baz); end

^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1214
def visit_parameters_node(node)
  params = []

  if node.requireds.any?
    node.requireds.each do |required|
      if required.is_a?(RequiredParameterNode)
        params << visit(required)
      else
        compiler = copy_compiler(in_destructure: true)
        params << required.accept(compiler)
      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|
      if post.is_a?(RequiredParameterNode)
        params << visit(post)
      else
        compiler = copy_compiler(in_destructure: true)
        params << post.accept(compiler)
      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) click to toggle source

() ^^

(1) ^^^

# File lib/prism/translation/parser/compiler.rb, line 1253
def visit_parentheses_node(node)
  builder.begin(
    token(node.opening_loc),
    visit(node.body),
    token(node.closing_loc)
  )
end
visit_pinned_expression_node(node) click to toggle source

foo => ^(bar)

^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1263
def visit_pinned_expression_node(node)
  expression = builder.begin(token(node.lparen_loc), visit(node.expression), token(node.rparen_loc))
  builder.pin(token(node.operator_loc), expression)
end
visit_pinned_variable_node(node) click to toggle source

foo = 1 and bar => ^foo

^^^^
# File lib/prism/translation/parser/compiler.rb, line 1270
def visit_pinned_variable_node(node)
  builder.pin(token(node.operator_loc), visit(node.variable))
end
visit_post_execution_node(node) click to toggle source

END {}

# File lib/prism/translation/parser/compiler.rb, line 1275
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) click to toggle source

BEGIN {}

# File lib/prism/translation/parser/compiler.rb, line 1285
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) click to toggle source

The top-level program node.

# File lib/prism/translation/parser/compiler.rb, line 1295
def visit_program_node(node)
  visit(node.statements)
end
visit_range_node(node) click to toggle source

0..5 ^^^^

# File lib/prism/translation/parser/compiler.rb, line 1301
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
Also aliased as: visit_flip_flop_node
visit_rational_node(node) click to toggle source

1r ^^

# File lib/prism/translation/parser/compiler.rb, line 1323
def visit_rational_node(node)
  visit_numeric(node, builder.rational([rational_value(node), srange(node.location)]))
end
visit_redo_node(node) click to toggle source

redo ^^^^

# File lib/prism/translation/parser/compiler.rb, line 1329
def visit_redo_node(node)
  builder.keyword_cmd(:redo, token(node.location))
end
visit_regular_expression_node(node) click to toggle source

/foo/ ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1335
def visit_regular_expression_node(node)
  builder.regexp_compose(
    token(node.opening_loc),
    [builder.string_internal(token(node.content_loc))],
    [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
Also aliased as: visit_match_last_line_node
visit_required_keyword_parameter_node(node) click to toggle source

def foo(bar:); end

^^^^
# File lib/prism/translation/parser/compiler.rb, line 1350
def visit_required_keyword_parameter_node(node)
  builder.kwarg([node.name, srange(node.name_loc)])
end
visit_required_parameter_node(node) click to toggle source

def foo(bar); end

^^^
# File lib/prism/translation/parser/compiler.rb, line 1356
def visit_required_parameter_node(node)
  builder.arg(token(node.location))
end
visit_rescue_modifier_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1362
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) click to toggle source

begin; rescue; end

^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1380
def visit_rescue_node(node)
  raise CompilationError, "Cannot directly compile rescue nodes"
end
visit_rest_parameter_node(node) click to toggle source

def foo(*bar); end

^^^^

def foo(*); end

^
# File lib/prism/translation/parser/compiler.rb, line 1389
def visit_rest_parameter_node(node)
  builder.restarg(token(node.operator_loc), token(node.name_loc))
end
visit_retry_node(node) click to toggle source

retry ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1395
def visit_retry_node(node)
  builder.keyword_cmd(:retry, token(node.location))
end
visit_return_node(node) click to toggle source

return ^^^^^^

return 1 ^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1404
def visit_return_node(node)
  builder.keyword_cmd(
    :return,
    token(node.keyword_loc),
    nil,
    visit(node.arguments) || [],
    nil
  )
end
visit_self_node(node) click to toggle source

self ^^^^

# File lib/prism/translation/parser/compiler.rb, line 1416
def visit_self_node(node)
  builder.self(token(node.location))
end
visit_singleton_class_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1422
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) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1434
def visit_source_encoding_node(node)
  builder.accessible(builder.__ENCODING__(token(node.location)))
end
visit_source_file_node(node) click to toggle source

__FILE__ ^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1440
def visit_source_file_node(node)
  builder.accessible(builder.__FILE__(token(node.location)))
end
visit_source_line_node(node) click to toggle source

__LINE__ ^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1446
def visit_source_line_node(node)
  builder.accessible(builder.__LINE__(token(node.location)))
end
visit_splat_node(node) click to toggle source

foo(*bar)

^^^^

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

^^^^

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

^
# File lib/prism/translation/parser/compiler.rb, line 1458
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) click to toggle source

A list of statements.

# File lib/prism/translation/parser/compiler.rb, line 1471
def visit_statements_node(node)
  builder.compstmt(visit_all(node.body))
end
visit_string_node(node) click to toggle source

“foo” ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1477
def visit_string_node(node)
  if node.heredoc?
    children, closing = visit_heredoc(node.to_interpolated)
    builder.string_compose(token(node.opening_loc), children, closing)
  elsif node.opening == "?"
    builder.character([node.unescaped, srange(node.location)])
  else
    builder.string_compose(
      token(node.opening_loc),
      [builder.string_internal([node.unescaped, srange(node.content_loc)])],
      token(node.closing_loc)
    )
  end
end
visit_super_node(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1494
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) click to toggle source

:foo ^^^^

# File lib/prism/translation/parser/compiler.rb, line 1517
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
    builder.symbol_compose(
      token(node.opening_loc),
      [builder.string_internal([node.unescaped, srange(node.value_loc)])],
      token(node.closing_loc)
    )
  end
end
visit_true_node(node) click to toggle source

true ^^^^

# File lib/prism/translation/parser/compiler.rb, line 1535
def visit_true_node(node)
  builder.true(token(node.location))
end
visit_undef_node(node) click to toggle source

undef foo ^^^^^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1541
def visit_undef_node(node)
  builder.undef_method(token(node.keyword_loc), visit_all(node.names))
end
visit_unless_node(node) click to toggle source

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

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

# File lib/prism/translation/parser/compiler.rb, line 1550
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 node.then_keyword_loc
        token(node.then_keyword_loc)
      else
        srange_find(node.predicate.location.end_offset, (node.statements&.location || node.consequent&.location || node.end_keyword_loc).start_offset, [";"])
      end,
      visit(node.consequent),
      token(node.consequent&.else_keyword_loc),
      visit(node.statements),
      token(node.end_keyword_loc)
    )
  else
    builder.condition_mod(
      visit(node.consequent),
      visit(node.statements),
      token(node.keyword_loc),
      visit(node.predicate)
    )
  end
end
visit_until_node(node) click to toggle source

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

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

# File lib/prism/translation/parser/compiler.rb, line 1580
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),
      srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, [";", "do"]),
      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) click to toggle source

case foo; when bar; end

^^^^^^^^^^^^^
# File lib/prism/translation/parser/compiler.rb, line 1602
def visit_when_node(node)
  builder.when(
    token(node.keyword_loc),
    visit_all(node.conditions),
    srange_find(node.conditions.last.location.end_offset, node.statements&.location&.start_offset || (node.conditions.last.location.end_offset + 1), [";", "then"]),
    visit(node.statements)
  )
end
visit_while_node(node) click to toggle source

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

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

# File lib/prism/translation/parser/compiler.rb, line 1616
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),
      srange_find(node.predicate.location.end_offset, (node.statements&.location || node.closing_loc).start_offset, [";", "do"]),
      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) click to toggle source

‘foo` ^^^^^

# File lib/prism/translation/parser/compiler.rb, line 1638
def visit_x_string_node(node)
  if node.heredoc?
    children, closing = visit_heredoc(node.to_interpolated)
    builder.xstring_compose(token(node.opening_loc), children, closing)
  else
    builder.xstring_compose(
      token(node.opening_loc),
      [builder.string_internal([node.unescaped, srange(node.content_loc)])],
      token(node.closing_loc)
    )
  end
end
visit_yield_node(node) click to toggle source

yield ^^^^^

yield 1 ^^^^^^^

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

Private Instance Methods

copy_compiler(forwarding: self.forwarding, in_destructure: self.in_destructure, in_pattern: self.in_pattern) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1670
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) click to toggle source

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.

# File lib/prism/translation/parser/compiler.rb, line 1677
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
imaginary_value(node) click to toggle source

Because we have mutated the AST to allow for newlines in the middle of a rational, we need to manually handle the value here.

# File lib/prism/translation/parser/compiler.rb, line 1691
def imaginary_value(node)
  Complex(0, node.numeric.is_a?(RationalNode) ? rational_value(node.numeric) : node.numeric.value)
end
numeric_negate(message_loc, receiver) click to toggle source

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.

# File lib/prism/translation/parser/compiler.rb, line 1700
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, :imaginary_node
    receiver.copy(numeric: numeric_negate(message_loc, receiver.numeric), location: message_loc.join(receiver.location))
  end
end
procarg0?(parameters) click to toggle source

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.

# File lib/prism/translation/parser/compiler.rb, line 1712
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
rational_value(node) click to toggle source

Because we have mutated the AST to allow for newlines in the middle of a rational, we need to manually handle the value here.

# File lib/prism/translation/parser/compiler.rb, line 1725
def rational_value(node)
  if node.numeric.is_a?(IntegerNode)
    Rational(node.numeric.value)
  else
    Rational(node.slice.gsub(/\s/, "").chomp("r"))
  end
end
srange(location) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1739
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, tokens) click to toggle source

Constructs a new source range by finding the given tokens between the given start offset and end offset. If the needle is not found, it returns nil.

# File lib/prism/translation/parser/compiler.rb, line 1751
def srange_find(start_offset, end_offset, tokens)
  tokens.find do |token|
    next unless (index = source_buffer.source.byteslice(start_offset...end_offset).index(token))
    offset = start_offset + index
    return [token, Range.new(source_buffer, offset_cache[offset], offset_cache[offset + token.length])]
  end
end
srange_offsets(start_offset, end_offset) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1744
def srange_offsets(start_offset, end_offset)
  Range.new(source_buffer, offset_cache[start_offset], offset_cache[end_offset])
end
token(location) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1760
def token(location)
  [location.slice, Range.new(source_buffer, offset_cache[location.start_offset], offset_cache[location.end_offset])] if location
end
visit_block(call, block) click to toggle source

Visit a block node on a call.

# File lib/prism/translation/parser/compiler.rb, line 1765
def visit_block(call, block)
  if block
    parameters = block.parameters

    builder.block(
      call,
      token(block.opening_loc),
      if parameters.nil?
        builder.args(nil, [], nil, false)
      elsif parameters.is_a?(NumberedParametersNode)
        visit(parameters)
      else
        builder.args(
          token(parameters.opening_loc),
          if procarg0?(parameters.parameters)
            parameter = parameters.parameters.requireds.first
            [builder.procarg0(visit(parameter))].concat(visit_all(parameters.locals))
          else
            visit(parameters)
          end,
          token(parameters.closing_loc),
          false
        )
      end,
      block.body&.accept(copy_compiler(forwarding: parameters.is_a?(NumberedParametersNode) ? [] : find_forwarding(parameters&.parameters))),
      token(block.closing_loc)
    )
  else
    call
  end
end
visit_heredoc(node) click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1798
def visit_heredoc(node)
  children = []
  node.parts.each do |part|
    pushing =
      if part.is_a?(StringNode) && part.unescaped.include?("\n")
        unescaped = part.unescaped.lines(chomp: true)
        escaped = part.content.lines(chomp: true)

        escaped_lengths =
          if node.opening.end_with?("'")
            escaped.map { |line| line.bytesize + 1 }
          else
            escaped.chunk_while { |before, after| before.match?(/(?<!\\)\\$/) }.map { |line| line.join.bytesize + line.length }
          end

        start_offset = part.location.start_offset
        end_offset = nil

        unescaped.zip(escaped_lengths).map do |unescaped_line, escaped_length|
          end_offset = start_offset + (escaped_length || 0)
          inner_part = builder.string_internal(["#{unescaped_line}\n", srange_offsets(start_offset, end_offset)])
          start_offset = end_offset
          inner_part
        end
      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")
        children.last.children.first << child.children.first
      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))]

  [children, closing_t]
end
visit_numeric(node, value) click to toggle source

Visit a numeric node and account for the optional sign.

# File lib/prism/translation/parser/compiler.rb, line 1844
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
within_pattern() { |copy_compiler(in_pattern: true)| ... } click to toggle source

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

# File lib/prism/translation/parser/compiler.rb, line 1856
def within_pattern
  begin
    parser.pattern_variables.push
    yield copy_compiler(in_pattern: true)
  ensure
    parser.pattern_variables.pop
  end
end