class Prism::Translation::RubyParser::Compiler

A prism visitor that builds Sexp objects.

Attributes

This is the name of the file that we are compiling. We set it on every Sexp object that is generated, and also use it to compile __FILE__ nodes.

in_def [R]

Class variables will change their type based on if they are inside of a method definition or not, so we need to track that state.

in_pattern [R]

Some nodes will change their representation if they are inside of a pattern, so we need to track that state.

Public Class Methods

new (file, in_def: false, in_pattern: false)

Source

# File lib/prism/translation/ruby_parser.rb, line 32
def initialize(file, in_def: false, in_pattern: false)
  @file = file
  @in_def = in_def
  @in_pattern = in_pattern
end

Initialize a new compiler with the given file name.

Public Instance Methods

visit_alias_global_variable_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 50
def visit_alias_global_variable_node(node)
  s(node, :valias, node.new_name.name, node.old_name.name)
end

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

visit_alias_method_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 42
def visit_alias_method_node(node)
  s(node, :alias, visit(node.new_name), visit(node.old_name))
end

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

visit_alternation_pattern_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 58
def visit_alternation_pattern_node(node)
  s(node, :or, visit(node.left), visit(node.right))
end

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

visit_and_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 66
def visit_and_node(node)
  left = visit(node.left)

  if left[0] == :and
    # ruby_parser has the and keyword as right-associative as opposed to
    # prism which has it as left-associative. We reverse that
    # associativity here.
    nest = left
    nest = nest[2] while nest[2][0] == :and
    nest[2] = s(node, :and, nest[2], visit(node.right))
    left
  else
    s(node, :and, left, visit(node.right))
  end
end

a and b
^^^^^^^

visit_arguments_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 123
def visit_arguments_node(node)
  raise "Cannot visit arguments directly"
end

foo(bar)
    ^^^

visit_array_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 86
def visit_array_node(node)
  if in_pattern
    s(node, :array_pat, nil).concat(visit_all(node.elements))
  else
    s(node, :array).concat(visit_all(node.elements))
  end
end

[]
^^

visit_array_pattern_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 98
def visit_array_pattern_node(node)
  if node.constant.nil? && node.requireds.empty? && node.rest.nil? && node.posts.empty?
    s(node, :array_pat)
  else
    result = s(node, :array_pat, visit_pattern_constant(node.constant)).concat(visit_all(node.requireds))

    case node.rest
    when SplatNode
      result << :"*#{node.rest.expression&.name}"
    when ImplicitRestNode
      result << :*

      # This doesn't make any sense at all, but since we're trying to
      # replicate the behavior directly, we'll copy it.
      result.line(666)
    end

    result.concat(visit_all(node.posts))
  end
end

foo => [bar]
       ^^^^^

visit_assoc_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 131
def visit_assoc_node(node)
  [visit(node.key), visit(node.value)]
end

{ a: 1 }
  ^^^^

visit_assoc_splat_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 142
def visit_assoc_splat_node(node)
  if node.value.nil?
    [s(node, :kwsplat)]
  else
    [s(node, :kwsplat, visit(node.value))]
  end
end

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

{ **foo }
  ^^^^^

visit_back_reference_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 154
def visit_back_reference_read_node(node)
  s(node, :back_ref, node.name.to_s.delete_prefix("$").to_sym)
end

$+
^^

visit_begin_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 162
def visit_begin_node(node)
  result = node.statements.nil? ? s(node, :nil) : visit(node.statements)

  if !node.rescue_clause.nil?
    if !node.statements.nil?
      result = s(node.statements, :rescue, result, visit(node.rescue_clause))
    else
      result = s(node.rescue_clause, :rescue, visit(node.rescue_clause))
    end

    current = node.rescue_clause
    until (current = current.subsequent).nil?
      result << visit(current)
    end
  end

  if !node.else_clause&.statements.nil?
    result << visit(node.else_clause)
  end

  if !node.ensure_clause.nil?
    if !node.statements.nil? || !node.rescue_clause.nil? || !node.else_clause.nil?
      result = s(node.statements || node.rescue_clause || node.else_clause || node.ensure_clause, :ensure, result, visit(node.ensure_clause))
    else
      result = s(node.ensure_clause, :ensure, visit(node.ensure_clause))
    end
  end

  result
end

begin end
^^^^^^^^^

visit_block_argument_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 197
def visit_block_argument_node(node)
  s(node, :block_pass).tap do |result|
    result << visit(node.expression) unless node.expression.nil?
  end
end

foo(&bar)
    ^^^^

visit_block_local_variable_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 207
def visit_block_local_variable_node(node)
  node.name
end

foo { |; bar| }
         ^^^

visit_block_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 212
def visit_block_node(node)
  s(node, :block_pass, visit(node.expression))
end

A block on a keyword or method call.

visit_block_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 220
def visit_block_parameter_node(node)
  :"&#{node.name}"
end

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

visit_block_parameters_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 225
def visit_block_parameters_node(node)
  # If this block parameters has no parameters and is using pipes, then
  # it inherits its location from its shadow locals, even if they're not
  # on the same lines as the pipes.
  shadow_loc = true

  result =
    if node.parameters.nil?
      s(node, :args)
    else
      shadow_loc = false
      visit(node.parameters)
    end

  if node.opening == "("
    result.line = node.opening_loc.start_line
    result.line_max = node.closing_loc.end_line
    shadow_loc = false
  end

  if node.locals.any?
    shadow = s(node, :shadow).concat(visit_all(node.locals))
    shadow.line = node.locals.first.location.start_line
    shadow.line_max = node.locals.last.location.end_line
    result << shadow

    if shadow_loc
      result.line = shadow.line
      result.line_max = shadow.line_max
    end
  end

  result
end

A block’s parameters.

visit_break_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 267
def visit_break_node(node)
  if node.arguments.nil?
    s(node, :break)
  elsif node.arguments.arguments.length == 1
    s(node, :break, visit(node.arguments.arguments.first))
  else
    s(node, :break, s(node.arguments, :array).concat(visit_all(node.arguments.arguments)))
  end
end

break
^^^^^

break foo
^^^^^^^^^

visit_call_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 341
def visit_call_and_write_node(node)
  if op_asgn?(node)
    s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"&&")
  else
    s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"&&", visit_write_value(node.value))
  end
end

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

visit_call_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 287
def visit_call_node(node)
  case node.name
  when :!~
    return s(node, :not, visit(node.copy(name: :"=~")))
  when :=~
    if node.arguments&.arguments&.length == 1 && node.block.nil?
      case node.receiver
      when StringNode
        return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
      when RegularExpressionNode, InterpolatedRegularExpressionNode
        return s(node, :match2, visit(node.receiver), visit(node.arguments.arguments.first))
      end

      case node.arguments.arguments.first
      when RegularExpressionNode, InterpolatedRegularExpressionNode
        return s(node, :match3, visit(node.arguments.arguments.first), visit(node.receiver))
      end
    end
  end

  type = node.attribute_write? ? :attrasgn : :call
  type = :"safe_#{type}" if node.safe_navigation?

  arguments = node.arguments&.arguments || []
  write_value = arguments.pop if type == :attrasgn
  block = node.block

  if block.is_a?(BlockArgumentNode)
    arguments << block
    block = nil
  end

  result = s(node, type, visit(node.receiver), node.name).concat(visit_all(arguments))
  result << visit_write_value(write_value) unless write_value.nil?

  visit_block(node, result, block)
end

foo
^^^

foo.bar
^^^^^^^

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

visit_call_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 329
def visit_call_operator_write_node(node)
  if op_asgn?(node)
    s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, node.binary_operator)
  else
    s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.binary_operator, visit_write_value(node.value))
  end
end

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

visit_call_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 353
def visit_call_or_write_node(node)
  if op_asgn?(node)
    s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, :"||")
  else
    s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, :"||", visit_write_value(node.value))
  end
end

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

visit_call_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 378
def visit_call_target_node(node)
  s(node, :attrasgn, visit(node.receiver), node.name)
end

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

visit_capture_pattern_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 386
def visit_capture_pattern_node(node)
  visit(node.target) << visit(node.value)
end

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

visit_case_match_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 402
def visit_case_match_node(node)
  s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause)
end

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

visit_case_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 394
def visit_case_node(node)
  s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause)
end

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

visit_class_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 410
def visit_class_node(node)
  name =
    if node.constant_path.is_a?(ConstantReadNode)
      node.name
    else
      visit(node.constant_path)
    end

  result =
    if node.body.nil?
      s(node, :class, name, visit(node.superclass))
    elsif node.body.is_a?(StatementsNode)
      compiler = copy_compiler(in_def: false)
      s(node, :class, name, visit(node.superclass)).concat(node.body.body.map { |child| child.accept(compiler) })
    else
      s(node, :class, name, visit(node.superclass), node.body.accept(copy_compiler(in_def: false)))
    end

  attach_comments(result, node)
  result
end

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

visit_class_variable_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 463
def visit_class_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value)))
end

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

visit_class_variable_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 455
def visit_class_variable_operator_write_node(node)
  s(node, class_variable_write_type, node.name, s(node, :call, s(node, :cvar, node.name), node.binary_operator, visit_write_value(node.value)))
end

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

visit_class_variable_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 471
def visit_class_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :cvar, node.name), s(node, class_variable_write_type, node.name, visit_write_value(node.value)))
end

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

visit_class_variable_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 436
def visit_class_variable_read_node(node)
  s(node, :cvar, node.name)
end

@@foo
^^^^^

visit_class_variable_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 479
def visit_class_variable_target_node(node)
  s(node, class_variable_write_type, node.name)
end

@@foo, = bar
^^^^^

visit_class_variable_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 447
def visit_class_variable_write_node(node)
  s(node, class_variable_write_type, node.name, visit_write_value(node.value))
end

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

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

visit_constant_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 520
def visit_constant_and_write_node(node)
  s(node, :op_asgn_and, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value)))
end

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

visit_constant_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 512
def visit_constant_operator_write_node(node)
  s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.binary_operator, visit_write_value(node.value)))
end

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

visit_constant_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 528
def visit_constant_or_write_node(node)
  s(node, :op_asgn_or, s(node, :const, node.name), s(node, :cdecl, node.name, visit(node.value)))
end

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

visit_constant_path_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 575
def visit_constant_path_and_write_node(node)
  s(node, :op_asgn_and, visit(node.target), visit_write_value(node.value))
end

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

visit_constant_path_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 544
def visit_constant_path_node(node)
  if node.parent.nil?
    s(node, :colon3, node.name)
  else
    s(node, :colon2, visit(node.parent), node.name)
  end
end

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

visit_constant_path_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 567
def visit_constant_path_operator_write_node(node)
  s(node, :op_asgn, visit(node.target), node.binary_operator, visit_write_value(node.value))
end

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

visit_constant_path_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 583
def visit_constant_path_or_write_node(node)
  s(node, :op_asgn_or, visit(node.target), visit_write_value(node.value))
end

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

visit_constant_path_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 591
def visit_constant_path_target_node(node)
  inner =
    if node.parent.nil?
      s(node, :colon3, node.name)
    else
      s(node, :colon2, visit(node.parent), node.name)
    end

  s(node, :const, inner)
end

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

visit_constant_path_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 559
def visit_constant_path_write_node(node)
  s(node, :cdecl, visit(node.target), visit_write_value(node.value))
end

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

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

visit_constant_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 493
def visit_constant_read_node(node)
  s(node, :const, node.name)
end

Foo
^^^

visit_constant_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 536
def visit_constant_target_node(node)
  s(node, :cdecl, node.name)
end

Foo, = bar
^^^

visit_constant_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 504
def visit_constant_write_node(node)
  s(node, :cdecl, node.name, visit_write_value(node.value))
end

Foo = 1
^^^^^^^

Foo, Bar = 1
^^^  ^^^

visit_def_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 609
def visit_def_node(node)
  name = node.name_loc.slice.to_sym
  result =
    if node.receiver.nil?
      s(node, :defn, name)
    else
      s(node, :defs, visit(node.receiver), name)
    end

  attach_comments(result, node)
  result.line(node.name_loc.start_line)

  if node.parameters.nil?
    result << s(node, :args).line(node.name_loc.start_line)
  else
    result << visit(node.parameters)
  end

  if node.body.nil?
    result << s(node, :nil)
  elsif node.body.is_a?(StatementsNode)
    compiler = copy_compiler(in_def: true)
    result.concat(node.body.body.map { |child| child.accept(compiler) })
  else
    result << node.body.accept(copy_compiler(in_def: true))
  end
end

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

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

visit_defined_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 644
def visit_defined_node(node)
  s(node, :defined, visit(node.value))
end

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

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

visit_else_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 652
def visit_else_node(node)
  visit(node.statements)
end

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

visit_embedded_statements_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 660
def visit_embedded_statements_node(node)
  result = s(node, :evstr)
  result << visit(node.statements) unless node.statements.nil?
  result
end

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

visit_embedded_variable_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 670
def visit_embedded_variable_node(node)
  s(node, :evstr, visit(node.variable))
end

"foo #@bar"
     ^^^^^

visit_ensure_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 678
def visit_ensure_node(node)
  node.statements.nil? ? s(node, :nil) : visit(node.statements)
end

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

visit_false_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 686
def visit_false_node(node)
  s(node, :false)
end

false
^^^^^

visit_find_pattern_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 694
def visit_find_pattern_node(node)
  s(node, :find_pat, visit_pattern_constant(node.constant), :"*#{node.left.expression&.name}", *visit_all(node.requireds), :"*#{node.right.expression&.name}")
end

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

visit_flip_flop_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 702
def visit_flip_flop_node(node)
  if node.left.is_a?(IntegerNode) && node.right.is_a?(IntegerNode)
    s(node, :lit, Range.new(node.left.value, node.right.value, node.exclude_end?))
  else
    s(node, node.exclude_end? ? :flip3 : :flip2, visit(node.left), visit(node.right))
  end
end

if foo .. bar; end
   ^^^^^^^^^^

visit_float_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 714
def visit_float_node(node)
  s(node, :lit, node.value)
end

1.0
^^^

visit_for_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 722
def visit_for_node(node)
  s(node, :for, visit(node.collection), visit(node.index), visit(node.statements))
end

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

visit_forwarding_arguments_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 730
def visit_forwarding_arguments_node(node)
  s(node, :forward_args)
end

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

visit_forwarding_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 738
def visit_forwarding_parameter_node(node)
  s(node, :forward_args)
end

def foo(...); end
        ^^^

visit_forwarding_super_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 749
def visit_forwarding_super_node(node)
  visit_block(node, s(node, :zsuper), node.block)
end

super
^^^^^

super {}
^^^^^^^^

visit_global_variable_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 784
def visit_global_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value)))
end

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

visit_global_variable_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 776
def visit_global_variable_operator_write_node(node)
  s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.binary_operator, visit(node.value)))
end

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

visit_global_variable_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 792
def visit_global_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :gvar, node.name), s(node, :gasgn, node.name, visit_write_value(node.value)))
end

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

visit_global_variable_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 757
def visit_global_variable_read_node(node)
  s(node, :gvar, node.name)
end

$foo
^^^^

visit_global_variable_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 800
def visit_global_variable_target_node(node)
  s(node, :gasgn, node.name)
end

$foo, = bar
^^^^

visit_global_variable_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 768
def visit_global_variable_write_node(node)
  s(node, :gasgn, node.name, visit_write_value(node.value))
end

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

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

visit_hash_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 808
def visit_hash_node(node)
  s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
end

{}
^^

visit_hash_pattern_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 816
def visit_hash_pattern_node(node)
  result = s(node, :hash_pat, visit_pattern_constant(node.constant)).concat(node.elements.flat_map { |element| visit(element) })

  case node.rest
  when AssocSplatNode
    result << s(node.rest, :kwrest, :"**#{node.rest.value&.name}")
  when NoKeywordsParameterNode
    result << visit(node.rest)
  end

  result
end

foo => {}
       ^^

visit_if_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 839
def visit_if_node(node)
  s(node, :if, visit(node.predicate), visit(node.statements), visit(node.subsequent))
end

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

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

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

visit_imaginary_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 844
def visit_imaginary_node(node)
  s(node, :lit, node.value)
end

visit_implicit_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 852
def visit_implicit_node(node)
end

{ foo: }
  ^^^^

visit_implicit_rest_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 859
def visit_implicit_rest_node(node)
end

foo { |bar,| }
          ^

visit_in_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 866
def visit_in_node(node)
  pattern =
    if node.pattern.is_a?(ConstantPathNode)
      s(node.pattern, :const, visit(node.pattern))
    else
      node.pattern.accept(copy_compiler(in_pattern: true))
    end

  s(node, :in, pattern).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
end

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

visit_index_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 896
def visit_index_and_write_node(node)
  arglist = nil

  if !node.arguments.nil? || !node.block.nil?
    arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
    arglist << visit(node.block) if !node.block.nil?
  end

  s(node, :op_asgn1, visit(node.receiver), arglist, :"&&", visit_write_value(node.value))
end

foo[bar] &&= baz
^^^^^^^^^^^^^^^^

visit_index_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 881
def visit_index_operator_write_node(node)
  arglist = nil

  if !node.arguments.nil? || !node.block.nil?
    arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
    arglist << visit(node.block) if !node.block.nil?
  end

  s(node, :op_asgn1, visit(node.receiver), arglist, node.binary_operator, visit_write_value(node.value))
end

foo[bar] += baz
^^^^^^^^^^^^^^^

visit_index_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 911
def visit_index_or_write_node(node)
  arglist = nil

  if !node.arguments.nil? || !node.block.nil?
    arglist = s(node, :arglist).concat(visit_all(node.arguments&.arguments || []))
    arglist << visit(node.block) if !node.block.nil?
  end

  s(node, :op_asgn1, visit(node.receiver), arglist, :"||", visit_write_value(node.value))
end

foo[bar] ||= baz
^^^^^^^^^^^^^^^^

visit_index_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 926
def visit_index_target_node(node)
  arguments = visit_all(node.arguments&.arguments || [])
  arguments << visit(node.block) unless node.block.nil?

  s(node, :attrasgn, visit(node.receiver), :[]=).concat(arguments)
end

foo[bar], = 1
^^^^^^^^

visit_instance_variable_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 964
def visit_instance_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value)))
end

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

visit_instance_variable_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 956
def visit_instance_variable_operator_write_node(node)
  s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.binary_operator, visit_write_value(node.value)))
end

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

visit_instance_variable_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 972
def visit_instance_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :ivar, node.name), s(node, :iasgn, node.name, visit(node.value)))
end

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

visit_instance_variable_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 937
def visit_instance_variable_read_node(node)
  s(node, :ivar, node.name)
end

@foo
^^^^

visit_instance_variable_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 980
def visit_instance_variable_target_node(node)
  s(node, :iasgn, node.name)
end

@foo, = bar
^^^^

visit_instance_variable_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 948
def visit_instance_variable_write_node(node)
  s(node, :iasgn, node.name, visit_write_value(node.value))
end

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

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

visit_integer_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 988
def visit_integer_node(node)
  s(node, :lit, node.value)
end

1
^

visit_interpolated_match_last_line_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 996
def visit_interpolated_match_last_line_node(node)
  parts = visit_interpolated_parts(node.parts)
  regexp =
    if parts.length == 1
      s(node, :lit, Regexp.new(parts.first, node.options))
    else
      s(node, :dregx).concat(parts).tap do |result|
        options = node.options
        result << options if options != 0
      end
    end

  s(node, :match, regexp)
end

if /foo #{bar}/ then end
   ^^^^^^^^^^^^

visit_interpolated_regular_expression_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1015
def visit_interpolated_regular_expression_node(node)
  parts = visit_interpolated_parts(node.parts)

  if parts.length == 1
    s(node, :lit, Regexp.new(parts.first, node.options))
  else
    s(node, :dregx).concat(parts).tap do |result|
      options = node.options
      result << options if options != 0
    end
  end
end

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

visit_interpolated_string_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1032
def visit_interpolated_string_node(node)
  parts = visit_interpolated_parts(node.parts)
  parts.length == 1 ? s(node, :str, parts.first) : s(node, :dstr).concat(parts)
end

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

visit_interpolated_symbol_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1041
def visit_interpolated_symbol_node(node)
  parts = visit_interpolated_parts(node.parts)
  parts.length == 1 ? s(node, :lit, parts.first.to_sym) : s(node, :dsym).concat(parts)
end

:"foo #{bar}"
^^^^^^^^^^^^^

visit_interpolated_x_string_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1050
def visit_interpolated_x_string_node(node)
  source = node.heredoc? ? node.parts.first : node
  parts = visit_interpolated_parts(node.parts)
  parts.length == 1 ? s(source, :xstr, parts.first) : s(source, :dxstr).concat(parts)
end

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

visit_it_local_variable_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1133
def visit_it_local_variable_read_node(node)
  s(node, :call, nil, :it)
end

-> { it }
     ^^

visit_keyword_hash_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1141
def visit_keyword_hash_node(node)
  s(node, :hash).concat(node.elements.flat_map { |element| visit(element) })
end

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

visit_keyword_rest_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1152
def visit_keyword_rest_parameter_node(node)
  :"**#{node.name}"
end

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

def foo(**); end
        ^^

visit_lambda_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1157
def visit_lambda_node(node)
  parameters =
    case node.parameters
    when nil, ItParametersNode, NumberedParametersNode
      0
    else
      visit(node.parameters)
    end

  if node.body.nil?
    s(node, :iter, s(node, :lambda), parameters)
  else
    s(node, :iter, s(node, :lambda), parameters, visit(node.body))
  end
end

-> {}

visit_local_variable_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1208
def visit_local_variable_and_write_node(node)
  s(node, :op_asgn_and, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value)))
end

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

visit_local_variable_operator_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1200
def visit_local_variable_operator_write_node(node)
  s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.binary_operator, visit_write_value(node.value)))
end

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

visit_local_variable_or_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1216
def visit_local_variable_or_write_node(node)
  s(node, :op_asgn_or, s(node, :lvar, node.name), s(node, :lasgn, node.name, visit_write_value(node.value)))
end

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

visit_local_variable_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1177
def visit_local_variable_read_node(node)
  if node.name.match?(/^_\d$/)
    s(node, :call, nil, node.name)
  else
    s(node, :lvar, node.name)
  end
end

foo
^^^

visit_local_variable_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1224
def visit_local_variable_target_node(node)
  s(node, :lasgn, node.name)
end

foo, = bar
^^^

visit_local_variable_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1192
def visit_local_variable_write_node(node)
  s(node, :lasgn, node.name, visit_write_value(node.value))
end

foo = 1
^^^^^^^

foo, bar = 1
^^^  ^^^

visit_match_last_line_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1232
def visit_match_last_line_node(node)
  s(node, :match, s(node, :lit, Regexp.new(node.unescaped, node.options)))
end

if /foo/ then end
   ^^^^^

visit_match_predicate_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1240
def visit_match_predicate_node(node)
  s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil)
end

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

visit_match_required_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1248
def visit_match_required_node(node)
  s(node, :case, visit(node.value), s(node, :in, node.pattern.accept(copy_compiler(in_pattern: true)), nil), nil)
end

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

visit_match_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1256
def visit_match_write_node(node)
  s(node, :match2, visit(node.call.receiver), visit(node.call.arguments.arguments.first))
end

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

visit_missing_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1263
def visit_missing_node(node)
  raise "Cannot visit missing node directly"
end

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

visit_module_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1271
def visit_module_node(node)
  name =
    if node.constant_path.is_a?(ConstantReadNode)
      node.name
    else
      visit(node.constant_path)
    end

  result =
    if node.body.nil?
      s(node, :module, name)
    elsif node.body.is_a?(StatementsNode)
      compiler = copy_compiler(in_def: false)
      s(node, :module, name).concat(node.body.body.map { |child| child.accept(compiler) })
    else
      s(node, :module, name, node.body.accept(copy_compiler(in_def: false)))
    end

  attach_comments(result, node)
  result
end

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

visit_multi_target_node (node)

Source

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

  s(node, :masgn, s(node, :array).concat(visit_all(targets)))
end

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

visit_multi_write_node (node)

Source

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

  value =
    if node.value.is_a?(ArrayNode) && node.value.opening_loc.nil?
      if node.value.elements.length == 1 && node.value.elements.first.is_a?(SplatNode)
        visit(node.value.elements.first)
      else
        visit(node.value)
      end
    else
      s(node.value, :to_ary, visit(node.value))
    end

  s(node, :masgn, s(node, :array).concat(visit_all(targets)), value)
end

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

visit_next_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1335
def visit_next_node(node)
  if node.arguments.nil?
    s(node, :next)
  elsif node.arguments.arguments.length == 1
    argument = node.arguments.arguments.first
    s(node, :next, argument.is_a?(SplatNode) ? s(node, :svalue, visit(argument)) : visit(argument))
  else
    s(node, :next, s(node, :array).concat(visit_all(node.arguments.arguments)))
  end
end

next
^^^^

next foo
^^^^^^^^

visit_nil_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1350
def visit_nil_node(node)
  s(node, :nil)
end

nil
^^^

visit_no_keywords_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1358
def visit_no_keywords_parameter_node(node)
  in_pattern ? s(node, :kwrest, :"**nil") : :"**nil"
end

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

visit_numbered_parameters_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1366
def visit_numbered_parameters_node(node)
  raise "Cannot visit numbered parameters directly"
end

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

visit_numbered_reference_read_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1374
def visit_numbered_reference_read_node(node)
  s(node, :nth_ref, node.number)
end

$1
^^

visit_optional_keyword_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1382
def visit_optional_keyword_parameter_node(node)
  s(node, :kwarg, node.name, visit(node.value))
end

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

visit_optional_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1390
def visit_optional_parameter_node(node)
  s(node, :lasgn, node.name, visit(node.value))
end

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

visit_or_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1398
def visit_or_node(node)
  left = visit(node.left)

  if left[0] == :or
    # ruby_parser has the or keyword as right-associative as opposed to
    # prism which has it as left-associative. We reverse that
    # associativity here.
    nest = left
    nest = nest[2] while nest[2][0] == :or
    nest[2] = s(node, :or, nest[2], visit(node.right))
    left
  else
    s(node, :or, left, visit(node.right))
  end
end

a or b
^^^^^^

visit_parameters_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1418
def visit_parameters_node(node)
  children =
    node.compact_child_nodes.map do |element|
      if element.is_a?(MultiTargetNode)
        visit_destructured_parameter(element)
      else
        visit(element)
      end
    end

  s(node, :args).concat(children)
end

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

visit_parentheses_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1460
def visit_parentheses_node(node)
  if node.body.nil?
    s(node, :nil)
  else
    visit(node.body)
  end
end

()
^^

(1)
^^^

visit_pinned_expression_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1472
def visit_pinned_expression_node(node)
  node.expression.accept(copy_compiler(in_pattern: false))
end

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

visit_pinned_variable_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1480
def visit_pinned_variable_node(node)
  if node.variable.is_a?(LocalVariableReadNode) && node.variable.name.match?(/^_\d$/)
    s(node, :lvar, node.variable.name)
  else
    visit(node.variable)
  end
end

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

visit_post_execution_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1489
def visit_post_execution_node(node)
  s(node, :iter, s(node, :postexe), 0, visit(node.statements))
end

END {}

visit_pre_execution_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1494
def visit_pre_execution_node(node)
  s(node, :iter, s(node, :preexe), 0, visit(node.statements))
end

BEGIN {}

visit_program_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1499
def visit_program_node(node)
  visit(node.statements)
end

The top-level program node.

visit_range_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1507
def visit_range_node(node)
  if !in_pattern && !node.left.nil? && !node.right.nil? && ([node.left.type, node.right.type] - %i[nil_node integer_node]).empty?
    left = node.left.value if node.left.is_a?(IntegerNode)
    right = node.right.value if node.right.is_a?(IntegerNode)
    s(node, :lit, Range.new(left, right, node.exclude_end?))
  else
    s(node, node.exclude_end? ? :dot3 : :dot2, visit_range_bounds_node(node.left), visit_range_bounds_node(node.right))
  end
end

0..5
^^^^

visit_rational_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1531
def visit_rational_node(node)
  s(node, :lit, node.value)
end

1r
^^

visit_redo_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1539
def visit_redo_node(node)
  s(node, :redo)
end

redo
^^^^

visit_regular_expression_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1547
def visit_regular_expression_node(node)
  s(node, :lit, Regexp.new(node.unescaped, node.options))
end

/foo/
^^^^^

visit_required_keyword_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1555
def visit_required_keyword_parameter_node(node)
  s(node, :kwarg, node.name)
end

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

visit_required_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1563
def visit_required_parameter_node(node)
  node.name
end

def foo(bar); end
        ^^^

visit_rescue_modifier_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1571
def visit_rescue_modifier_node(node)
  s(node, :rescue, visit(node.expression), s(node.rescue_expression, :resbody, s(node.rescue_expression, :array), visit(node.rescue_expression)))
end

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

visit_rescue_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1579
def visit_rescue_node(node)
  exceptions =
    if node.exceptions.length == 1 && node.exceptions.first.is_a?(SplatNode)
      visit(node.exceptions.first)
    else
      s(node, :array).concat(visit_all(node.exceptions))
    end

  if !node.reference.nil?
    exceptions << (visit(node.reference) << s(node.reference, :gvar, :"$!"))
  end

  s(node, :resbody, exceptions).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
end

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

visit_rest_parameter_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1601
def visit_rest_parameter_node(node)
  :"*#{node.name}"
end

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

def foo(*); end
        ^

visit_retry_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1609
def visit_retry_node(node)
  s(node, :retry)
end

retry
^^^^^

visit_return_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1620
def visit_return_node(node)
  if node.arguments.nil?
    s(node, :return)
  elsif node.arguments.arguments.length == 1
    argument = node.arguments.arguments.first
    s(node, :return, argument.is_a?(SplatNode) ? s(node, :svalue, visit(argument)) : visit(argument))
  else
    s(node, :return, s(node, :array).concat(visit_all(node.arguments.arguments)))
  end
end

return
^^^^^^

return 1
^^^^^^^^

visit_self_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1635
def visit_self_node(node)
  s(node, :self)
end

self
^^^^

visit_shareable_constant_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1640
def visit_shareable_constant_node(node)
  visit(node.write)
end

A shareable constant.

visit_singleton_class_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1648
def visit_singleton_class_node(node)
  s(node, :sclass, visit(node.expression)).tap do |sexp|
    sexp << node.body.accept(copy_compiler(in_def: false)) unless node.body.nil?
  end
end

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

visit_source_encoding_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1658
def visit_source_encoding_node(node)
  # TODO
  s(node, :colon2, s(node, :const, :Encoding), :UTF_8)
end

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

visit_source_file_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1667
def visit_source_file_node(node)
  s(node, :str, node.filepath)
end

__FILE__
^^^^^^^^

visit_source_line_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1675
def visit_source_line_node(node)
  s(node, :lit, node.location.start_line)
end

__LINE__
^^^^^^^^

visit_splat_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1689
def visit_splat_node(node)
  if node.expression.nil?
    s(node, :splat)
  else
    s(node, :splat, visit(node.expression))
  end
end

foo(*bar)
    ^^^^

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

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

visit_statements_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1698
def visit_statements_node(node)
  first, *rest = node.body

  if rest.empty?
    visit(first)
  else
    s(node, :block).concat(visit_all(node.body))
  end
end

A list of statements.

visit_string_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1712
def visit_string_node(node)
  unescaped = node.unescaped

  if node.forced_binary_encoding?
    unescaped = unescaped.dup
    unescaped.force_encoding(Encoding::BINARY)
  end

  s(node, :str, unescaped)
end

"foo"
^^^^^

visit_super_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1727
def visit_super_node(node)
  arguments = node.arguments&.arguments || []
  block = node.block

  if block.is_a?(BlockArgumentNode)
    arguments << block
    block = nil
  end

  visit_block(node, s(node, :super).concat(visit_all(arguments)), block)
end

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

visit_symbol_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1743
def visit_symbol_node(node)
  node.value == "!@" ? s(node, :lit, :"!@") : s(node, :lit, node.unescaped.to_sym)
end

:foo
^^^^

visit_true_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1751
def visit_true_node(node)
  s(node, :true)
end

true
^^^^

visit_undef_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1759
def visit_undef_node(node)
  names = node.names.map { |name| s(node, :undef, visit(name)) }
  names.length == 1 ? names.first : s(node, :block).concat(names)
end

undef foo
^^^^^^^^^

visit_unless_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1771
def visit_unless_node(node)
  s(node, :if, visit(node.predicate), visit(node.else_clause), visit(node.statements))
end

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

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

visit_until_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1782
def visit_until_node(node)
  s(node, :until, visit(node.predicate), visit(node.statements), !node.begin_modifier?)
end

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

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

visit_when_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1790
def visit_when_node(node)
  s(node, :when, s(node, :array).concat(visit_all(node.conditions))).concat(node.statements.nil? ? [nil] : visit_all(node.statements.body))
end

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

visit_while_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1801
def visit_while_node(node)
  s(node, :while, visit(node.predicate), visit(node.statements), !node.begin_modifier?)
end

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

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

visit_x_string_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1809
def visit_x_string_node(node)
  result = s(node, :xstr, node.unescaped)

  if node.heredoc?
    result.line = node.content_loc.start_line
    result.line_max = node.content_loc.end_line
  end

  result
end

`foo`
^^^^^

visit_yield_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1827
def visit_yield_node(node)
  s(node, :yield).concat(visit_all(node.arguments&.arguments || []))
end

yield
^^^^^

yield 1
^^^^^^^

Private Instance Methods

attach_comments (sexp, node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1834
def attach_comments(sexp, node)
  return unless node.comments
  return if node.comments.empty?

  extra = node.location.start_line - node.comments.last.location.start_line
  comments = node.comments.map(&:slice)
  comments.concat([nil] * [0, extra].max)
  sexp.comments = comments.join("\n")
end

Attach prism comments to the given sexp.

class_variable_write_type ()

Source

# File lib/prism/translation/ruby_parser.rb, line 485
        def class_variable_write_type
  in_def ? :cvasgn : :cvdecl
end

If a class variable is written within a method definition, it has a different type than everywhere else.

copy_compiler (in_def: self.in_def, in_pattern: self.in_pattern)

Source

# File lib/prism/translation/ruby_parser.rb, line 1845
def copy_compiler(in_def: self.in_def, in_pattern: self.in_pattern)
  Compiler.new(file, in_def: in_def, in_pattern: in_pattern)
end

Create a new compiler with the given options.

op_asgn? (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 364
        def op_asgn?(node)
  node.call_operator == "::" || (node.value.is_a?(CallNode) && node.value.opening_loc.nil? && !node.value.arguments.nil?)
end

Call nodes with operators following them will either be op_asgn or op_asgn2 nodes. That is determined by their call operator and their right-hand side.

op_asgn_type (node, type)

Source

# File lib/prism/translation/ruby_parser.rb, line 370
        def op_asgn_type(node, type)
  node.safe_navigation? ? :"safe_#{type}" : type
end

Call nodes with operators following them can use &. as an operator, which changes their type by prefixing “safe_”.

s (node, *arguments)

Source

# File lib/prism/translation/ruby_parser.rb, line 1850
def s(node, *arguments)
  result = Sexp.new(*arguments)
  result.file = file
  result.line = node.location.start_line
  result.line_max = node.location.end_line
  result
end

Create a new Sexp object from the given prism node and arguments.

visit_block (node, sexp, block)

Source

# File lib/prism/translation/ruby_parser.rb, line 1860
def visit_block(node, sexp, block)
  if block.nil?
    sexp
  else
    parameters =
      case block.parameters
      when nil, ItParametersNode, NumberedParametersNode
        0
      else
        visit(block.parameters)
      end

    if block.body.nil?
      s(node, :iter, sexp, parameters)
    else
      s(node, :iter, sexp, parameters, visit(block.body))
    end
  end
end

Visit a block node, which will modify the AST by wrapping the given visited node in an iter node.

visit_destructured_parameter (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1435
        def visit_destructured_parameter(node)
  children =
    [*node.lefts, *node.rest, *node.rights].map do |child|
      case child
      when RequiredParameterNode
        visit(child)
      when MultiTargetNode
        visit_destructured_parameter(child)
      when SplatNode
        :"*#{child.expression&.name}"
      else
        raise
      end
    end

  s(node, :masgn).concat(children)
end

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

visit_interpolated_parts (parts)

Source

# File lib/prism/translation/ruby_parser.rb, line 1057
        def visit_interpolated_parts(parts)
  visited = []

  parts.each do |part|
    result = visit(part)

    if result[0] == :evstr && result[1]
      if result[1][0] == :str
        visited << result[1]
      elsif result[1][0] == :dstr
        visited.concat(result[1][1..-1])
      else
        visited << result
      end
      visited << :space
    elsif result[0] == :dstr
      if !visited.empty? && part.parts[0].is_a?(StringNode)
        # If we are in the middle of an implicitly concatenated string,
        # we should not have a bare string as the first part. In this
        # case we need to visit just that first part and then we can
        # push the rest of the parts onto the visited array.
        result[1] = visit(part.parts[0])
      end
      visited.concat(result[1..-1])
    else
      visited << result
    end
  end

  state = :beginning #: :beginning | :string_content | :interpolated_content
  results = []

  visited.each_with_index do |result, index|
    case state
    when :beginning
      if result.is_a?(String)
        results << result
        state = :string_content
      elsif result.is_a?(Array) && result[0] == :str
        results << result[1]
        state = :string_content
      else
        results << ""
        results << result
        state = :interpolated_content
      end
    when :string_content
      if result == :space
        # continue
      elsif result.is_a?(String)
        results[0] = "#{results[0]}#{result}"
      elsif result.is_a?(Array) && result[0] == :str
        results[0] = "#{results[0]}#{result[1]}"
      else
        results << result
        state = :interpolated_content
      end
    when :interpolated_content
      if result == :space
        # continue
      elsif visited[index - 1] != :space && result.is_a?(Array) && result[0] == :str && results[-1][0] == :str && (results[-1].line_max == result.line)
        results[-1][1] = "#{results[-1][1]}#{result[1]}"
        results[-1].line_max = result.line_max
      else
        results << result
      end
    end
  end

  results
end

Visit the interpolated content of the string-like node.

visit_pattern_constant (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1881
def visit_pattern_constant(node)
  case node
  when nil
    # nothing
  when ConstantReadNode
    visit(node)
  else
    s(node, :const, visit(node))
  end
end

Pattern constants get wrapped in another layer of :const.

visit_range_bounds_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1519
        def visit_range_bounds_node(node)
  if node.is_a?(ParenthesesNode) && node.body.nil?
    s(node, :begin)
  else
    visit(node)
  end
end

If the bounds of a range node are empty parentheses, then they do not get replaced by their usual s(:nil), but instead are s(:begin).

visit_write_value (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1895
def visit_write_value(node)
  if node.is_a?(ArrayNode) && node.opening_loc.nil?
    if node.elements.length == 1 && node.elements.first.is_a?(SplatNode)
      s(node, :svalue, visit(node.elements.first))
    else
      s(node, :svalue, visit(node))
    end
  else
    visit(node)
  end
end

Visit the value of a write, which will be on the right-hand side of a write operator. Because implicit arrays can have splats, those could potentially be wrapped in an svalue node.