class Prism::Translation::RubyParser::Compiler - Documentation for Ruby 4.0
Description: class Prism::Translation::RubyParser::Compiler: A prism visitor that builds Sexp objects.
Keywords: ruby,class,Prism::Translation::RubyParser::Compiler

🔍

No recent searches

# class Prism::Translation::RubyParser::Compiler

A prism visitor that builds Sexp objects.

### Attributes

file [R]

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 37
    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 55
    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 47
    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 63
    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 71
    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 128
    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 91
    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 103
    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 136
    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 147
    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 159
    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 167
    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 202
    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 212
    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 217
    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 225
    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 230
    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 272
    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 346
    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 292
    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 334
    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 358
    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 383
    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 391
    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 407
    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 399
    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 415
    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 468
    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 460
    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 476
    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 441
    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 484
    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 452
    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 525
    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 517
    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 533
    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 580
    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 549
    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 572
    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 588
    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 596
    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 564
    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 498
    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 541
    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 509
    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 614
    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 649
    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 657
    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 665
    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 675
    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 683
    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 691
    def visit_false_node(node)
      s(node, :false)
    end

    false
    ^^^^^

visit_find_pattern_node (node)
Source

    # File lib/prism/translation/ruby_parser.rb, line 699
    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 707
    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 719
    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 727
    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 735
    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 743
    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 754
    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 789
    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 781
    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 797
    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 762
    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 805
    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 773
    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 813
    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 821
    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 844
    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 849
    def visit_imaginary_node(node)
      s(node, :lit, node.value)
    end

1i

visit_implicit_node (node)
Source

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

    { foo: }
      ^^^^

visit_implicit_rest_node (node)
Source

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

    foo { |bar,| }
              ^

visit_in_node (node)
Source

    # File lib/prism/translation/ruby_parser.rb, line 871
    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 901
    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 886
    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 916
    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 931
    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 969
    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 961
    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 977
    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 942
    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 985
    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 953
    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 993
    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 1001
    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 1020
    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 1037
    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 1046
    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 1055
    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 1138
    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 1146
    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 1157
    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 1162
    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 1213
    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 1205
    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 1221
    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 1182
    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 1229
    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 1197
    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 1237
    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 1245
    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 1253
    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 1261
    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 1268
    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 1276
    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 1302
    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 1314
    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 1340
    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 1355
    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 1363
    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 1371
    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 1379
    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 1387
    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 1395
    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 1403
    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 1423
    def visit_parameters_node(node)
      children =
        node.each_child_node.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 1465
    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 1477
    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 1485
    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 1494
    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 1499
    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 1504
    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 1512
    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 1536
    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 1544
    def visit_redo_node(node)
      s(node, :redo)
    end

    redo
    ^^^^

visit_regular_expression_node (node)
Source

    # File lib/prism/translation/ruby_parser.rb, line 1552
    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 1560
    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 1568
    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 1576
    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 1584
    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 1606
    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 1614
    def visit_retry_node(node)
      s(node, :retry)
    end

    retry
    ^^^^^

visit_return_node (node)
Source

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

    self
    ^^^^

visit_shareable_constant_node (node)
Source

    # File lib/prism/translation/ruby_parser.rb, line 1645
    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 1653
    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 1663
    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 1672
    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 1680
    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 1694
    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 1703
    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 1717
    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 1732
    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 1748
    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 1756
    def visit_true_node(node)
      s(node, :true)
    end

    true
    ^^^^

visit_undef_node (node)
Source

    # File lib/prism/translation/ruby_parser.rb, line 1764
    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 1776
    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 1787
    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 1795
    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 1806
    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 1814
    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 1832
    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 1839
    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 490
            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 1850
    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 369
            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 375
            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 1855
    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 1865
    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 1440
            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 1062
            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 1886
    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 1524
            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 1900
    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.