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

  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
end

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

visit_class_variable_and_write_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 459
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 451
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 467
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 432
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 475
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 443
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 516
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 508
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 524
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 571
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 540
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 563
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 579
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 587
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 555
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 489
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 532
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 500
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 605
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

  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 638
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 646
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 654
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 664
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 672
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 680
def visit_false_node(node)
  s(node, :false)
end

false
^^^^^

visit_find_pattern_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 688
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 696
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 708
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 716
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 724
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 732
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 743
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 778
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 770
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 786
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 751
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 794
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 762
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 802
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 810
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 833
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 838
def visit_imaginary_node(node)
  s(node, :lit, node.value)
end

visit_implicit_node (node)

Source

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

{ foo: }
  ^^^^

visit_implicit_rest_node (node)

Source

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

foo { |bar,| }
          ^

visit_in_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 860
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 890
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 875
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 905
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 920
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 958
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 950
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 966
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 931
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 974
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 942
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 982
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 990
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 1009
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 1026
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 1035
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 1044
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 1127
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 1135
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 1146
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 1151
def visit_lambda_node(node)
  parameters =
    case node.parameters
    when nil, NumberedParametersNode
      s(node, :args)
    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 1202
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 1194
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 1210
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 1171
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 1218
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 1186
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 1226
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 1234
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 1242
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 1250
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 1257
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 1265
def visit_module_node(node)
  name =
    if node.constant_path.is_a?(ConstantReadNode)
      node.name
    else
      visit(node.constant_path)
    end

  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
end

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

visit_multi_target_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1287
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 1299
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 1325
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 1340
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 1348
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 1356
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 1364
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 1372
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 1380
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 1388
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 1408
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 1450
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 1462
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 1470
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 1479
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 1484
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 1489
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 1497
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 1521
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 1529
def visit_redo_node(node)
  s(node, :redo)
end

redo
^^^^

visit_regular_expression_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1537
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 1545
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 1553
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 1561
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 1569
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 1591
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 1599
def visit_retry_node(node)
  s(node, :retry)
end

retry
^^^^^

visit_return_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1610
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 1625
def visit_self_node(node)
  s(node, :self)
end

self
^^^^

visit_shareable_constant_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1630
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 1638
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 1648
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 1657
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 1665
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 1679
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 1688
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 1702
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 1717
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 1733
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 1741
def visit_true_node(node)
  s(node, :true)
end

true
^^^^

visit_undef_node (node)

Source

# File lib/prism/translation/ruby_parser.rb, line 1749
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 1761
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 1772
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 1780
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 1791
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 1799
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 1817
def visit_yield_node(node)
  s(node, :yield).concat(visit_all(node.arguments&.arguments || []))
end

yield
^^^^^

yield 1
^^^^^^^

Private Instance Methods

class_variable_write_type ()

Source

# File lib/prism/translation/ruby_parser.rb, line 481
        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 1824
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 1829
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 1839
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 1425
        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 1051
        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 1860
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 1509
        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 1874
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.