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.
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.
Some nodes will change their representation if they are inside of a pattern, so we need to track that state.
Public Class Methods
Initialize a new compiler with the given file name.
# File lib/prism/translation/ruby_parser.rb, line 31 def initialize(file, in_def: false, in_pattern: false) @file = file @in_def = in_def @in_pattern = in_pattern end
Public Instance Methods
alias $foo $bar ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 45 def visit_alias_global_variable_node(node) s(node, :valias, node.new_name.name, node.old_name.name) end
alias foo bar ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 39 def visit_alias_method_node(node) s(node, :alias, visit(node.new_name), visit(node.old_name)) end
foo => bar | baz
^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 51 def visit_alternation_pattern_node(node) s(node, :or, visit(node.left), visit(node.right)) end
a and b ^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 57 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
foo(bar)
^^^
# File lib/prism/translation/ruby_parser.rb, line 108 def visit_arguments_node(node) raise "Cannot visit arguments directly" end
-
^^
# File lib/prism/translation/ruby_parser.rb, line 75 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
foo => [bar]
^^^^^
# File lib/prism/translation/ruby_parser.rb, line 85 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
{ a: 1 }
^^^^
# File lib/prism/translation/ruby_parser.rb, line 114 def visit_assoc_node(node) [visit(node.key), visit(node.value)] end
def foo(**); bar(**); end
^^
{ **foo }
^^^^^
# File lib/prism/translation/ruby_parser.rb, line 123 def visit_assoc_splat_node(node) if node.value.nil? [s(node, :kwsplat)] else [s(node, :kwsplat, visit(node.value))] end end
$+ ^^
# File lib/prism/translation/ruby_parser.rb, line 133 def visit_back_reference_read_node(node) s(node, :back_ref, node.name.name.delete_prefix("$").to_sym) end
begin end ^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 139 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
foo(&bar)
^^^^
# File lib/prism/translation/ruby_parser.rb, line 172 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| }
^^^
# File lib/prism/translation/ruby_parser.rb, line 180 def visit_block_local_variable_node(node) node.name end
A block on a keyword or method call.
# File lib/prism/translation/ruby_parser.rb, line 185 def visit_block_node(node) s(node, :block_pass, visit(node.expression)) end
def foo(&bar); end
^^^^
# File lib/prism/translation/ruby_parser.rb, line 191 def visit_block_parameter_node(node) :"&#{node.name}" end
A block’s parameters.
# File lib/prism/translation/ruby_parser.rb, line 196 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
break ^^^^^
break foo ^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 236 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
foo.bar &&= baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 304 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 ^^^
foo.bar ^^^^^^^
foo.bar() {} ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 254 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.bar += baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 294 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 ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 314 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, = 1 ^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 337 def visit_call_target_node(node) s(node, :attrasgn, visit(node.receiver), node.name) end
foo => bar => baz
^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 343 def visit_capture_pattern_node(node) visit(node.target) << visit(node.value) end
case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 355 def visit_case_match_node(node) s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause) end
case foo; when bar; end ^^^^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 349 def visit_case_node(node) s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.else_clause) end
class Foo; end ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 361 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
@@foo &&= bar ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 402 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 ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 396 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 ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 408 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 ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 381 def visit_class_variable_read_node(node) s(node, :cvar, node.name) end
@@foo, = bar ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 414 def visit_class_variable_target_node(node) s(node, class_variable_write_type, node.name) end
@@foo = 1 ^^^^^^^^^
@@foo, @@bar = 1 ^^^^^ ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 390 def visit_class_variable_write_node(node) s(node, class_variable_write_type, node.name, visit_write_value(node.value)) end
Foo &&= bar ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 447 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 ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 441 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 ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 453 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 &&= baz ^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 490 def visit_constant_path_and_write_node(node) s(node, :op_asgn_and, visit(node.target), visit_write_value(node.value)) end
Foo::Bar ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 465 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 += baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 484 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 ^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 496 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 ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 502 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 = 1 ^^^^^^^^^^^^
Foo::Foo, Bar::Bar = 1 ^^^^^^^^ ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 478 def visit_constant_path_write_node(node) s(node, :cdecl, visit(node.target), visit_write_value(node.value)) end
Foo ^^^
# File lib/prism/translation/ruby_parser.rb, line 426 def visit_constant_read_node(node) s(node, :const, node.name) end
Foo, = bar ^^^
# File lib/prism/translation/ruby_parser.rb, line 459 def visit_constant_target_node(node) s(node, :cdecl, node.name) end
Foo = 1 ^^^^^^^
Foo, Bar = 1 ^^^ ^^^
# File lib/prism/translation/ruby_parser.rb, line 435 def visit_constant_write_node(node) s(node, :cdecl, node.name, visit_write_value(node.value)) end
def foo; end ^^^^^^^^^^^^
def self.foo; end ^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 518 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
defined? a ^^^^^^^^^^
defined?(a) ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 549 def visit_defined_node(node) s(node, :defined, visit(node.value)) end
if foo then bar else baz end
^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 555 def visit_else_node(node) visit(node.statements) end
“foo #{bar}”
^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 561 def visit_embedded_statements_node(node) result = s(node, :evstr) result << visit(node.statements) unless node.statements.nil? result end
“foo #@bar”
^^^^^
# File lib/prism/translation/ruby_parser.rb, line 569 def visit_embedded_variable_node(node) s(node, :evstr, visit(node.variable)) end
begin; foo; ensure; bar; end
^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 575 def visit_ensure_node(node) node.statements.nil? ? s(node, :nil) : visit(node.statements) end
false ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 581 def visit_false_node(node) s(node, :false) end
foo => [*, bar, *]
^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 587 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
if foo .. bar; end
^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 593 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
1.0 ^^^
# File lib/prism/translation/ruby_parser.rb, line 603 def visit_float_node(node) s(node, :lit, node.value) end
for foo in bar do end ^^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 609 def visit_for_node(node) s(node, :for, visit(node.collection), visit(node.index), visit(node.statements)) end
def foo(…); bar(…); end
^^^
# File lib/prism/translation/ruby_parser.rb, line 615 def visit_forwarding_arguments_node(node) s(node, :forward_args) end
def foo(…); end
^^^
# File lib/prism/translation/ruby_parser.rb, line 621 def visit_forwarding_parameter_node(node) s(node, :forward_args) end
super ^^^^^
super {} ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 630 def visit_forwarding_super_node(node) visit_block(node, s(node, :zsuper), node.block) end
$foo &&= bar ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 657 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 ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 651 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 ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 663 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 ^^^^
# File lib/prism/translation/ruby_parser.rb, line 636 def visit_global_variable_read_node(node) s(node, :gvar, node.name) end
$foo, = bar ^^^^
# File lib/prism/translation/ruby_parser.rb, line 669 def visit_global_variable_target_node(node) s(node, :gasgn, node.name) end
$foo = 1 ^^^^^^^^
$foo, $bar = 1 ^^^^ ^^^^
# File lib/prism/translation/ruby_parser.rb, line 645 def visit_global_variable_write_node(node) s(node, :gasgn, node.name, visit_write_value(node.value)) end
{} ^^
# File lib/prism/translation/ruby_parser.rb, line 675 def visit_hash_node(node) s(node, :hash).concat(node.elements.flat_map { |element| visit(element) }) end
foo => {}
^^
# File lib/prism/translation/ruby_parser.rb, line 681 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
if foo then bar end ^^^^^^^^^^^^^^^^^^^
bar if foo ^^^^^^^^^^
foo ? bar : baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 702 def visit_if_node(node) s(node, :if, visit(node.predicate), visit(node.statements), visit(node.subsequent)) end
1i
# File lib/prism/translation/ruby_parser.rb, line 707 def visit_imaginary_node(node) s(node, :lit, node.value) end
{ foo: }
^^^^
# File lib/prism/translation/ruby_parser.rb, line 713 def visit_implicit_node(node) end
foo { |bar,| }
^
# File lib/prism/translation/ruby_parser.rb, line 718 def visit_implicit_rest_node(node) end
case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 723 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
foo &&= baz ^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 749 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 += baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 736 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 ||= baz ^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 762 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, = 1 ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 775 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 ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 805 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 ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 799 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 ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 811 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 ^^^^
# File lib/prism/translation/ruby_parser.rb, line 784 def visit_instance_variable_read_node(node) s(node, :ivar, node.name) end
@foo, = bar ^^^^
# File lib/prism/translation/ruby_parser.rb, line 817 def visit_instance_variable_target_node(node) s(node, :iasgn, node.name) end
@foo = 1 ^^^^^^^^
@foo, @bar = 1 ^^^^ ^^^^
# File lib/prism/translation/ruby_parser.rb, line 793 def visit_instance_variable_write_node(node) s(node, :iasgn, node.name, visit_write_value(node.value)) end
1 ^
# File lib/prism/translation/ruby_parser.rb, line 823 def visit_integer_node(node) s(node, :lit, node.value) end
if /foo #{bar}/ then end
^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 829 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
/foo #{bar}/ ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 846 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}” ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 861 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}” ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 868 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}` ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 875 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
-> { it }
^^
# File lib/prism/translation/ruby_parser.rb, line 947 def visit_it_local_variable_read_node(node) s(node, :call, nil, :it) end
foo(bar: baz)
^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 953 def visit_keyword_hash_node(node) s(node, :hash).concat(node.elements.flat_map { |element| visit(element) }) end
def foo(**bar); end
^^^^^
def foo(**); end
^^
# File lib/prism/translation/ruby_parser.rb, line 962 def visit_keyword_rest_parameter_node(node) :"**#{node.name}" end
-> {}
# File lib/prism/translation/ruby_parser.rb, line 967 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
foo &&= bar ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1010 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 ^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1004 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 ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1016 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 ^^^
# File lib/prism/translation/ruby_parser.rb, line 985 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, = bar ^^^
# File lib/prism/translation/ruby_parser.rb, line 1022 def visit_local_variable_target_node(node) s(node, :lasgn, node.name) end
foo = 1 ^^^^^^^
foo, bar = 1 ^^^ ^^^
# File lib/prism/translation/ruby_parser.rb, line 998 def visit_local_variable_write_node(node) s(node, :lasgn, node.name, visit_write_value(node.value)) end
if /foo/ then end
^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1028 def visit_match_last_line_node(node) s(node, :match, s(node, :lit, Regexp.new(node.unescaped, node.options))) end
foo in bar ^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1034 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 => bar ^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1040 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>foo)/ =~ bar ^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1046 def visit_match_write_node(node) s(node, :match2, visit(node.call.receiver), visit(node.call.arguments.arguments.first)) 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.
# File lib/prism/translation/ruby_parser.rb, line 1053 def visit_missing_node(node) raise "Cannot visit missing node directly" end
module Foo; end ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1059 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
foo, bar = baz ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1079 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 ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1089 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
next ^^^^
next foo ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1113 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
nil ^^^
# File lib/prism/translation/ruby_parser.rb, line 1126 def visit_nil_node(node) s(node, :nil) end
def foo(**nil); end
^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1132 def visit_no_keywords_parameter_node(node) in_pattern ? s(node, :kwrest, :"**nil") : :"**nil" end
-> { _1 + _2 } ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1138 def visit_numbered_parameters_node(node) raise "Cannot visit numbered parameters directly" end
$1 ^^
# File lib/prism/translation/ruby_parser.rb, line 1144 def visit_numbered_reference_read_node(node) s(node, :nth_ref, node.number) end
def foo(bar: baz); end
^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1150 def visit_optional_keyword_parameter_node(node) s(node, :kwarg, node.name, visit(node.value)) end
def foo(bar = 1); end
^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1156 def visit_optional_parameter_node(node) s(node, :lasgn, node.name, visit(node.value)) end
a or b ^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1162 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
def foo(bar, *baz); end
^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1180 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
() ^^
(1) ^^^
# File lib/prism/translation/ruby_parser.rb, line 1218 def visit_parentheses_node(node) if node.body.nil? s(node, :nil) else visit(node.body) end end
foo => ^(bar)
^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1228 def visit_pinned_expression_node(node) node.expression.accept(copy_compiler(in_pattern: false)) end
foo = 1 and bar => ^foo
^^^^
# File lib/prism/translation/ruby_parser.rb, line 1234 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
END {}
# File lib/prism/translation/ruby_parser.rb, line 1243 def visit_post_execution_node(node) s(node, :iter, s(node, :postexe), 0, visit(node.statements)) end
BEGIN {}
# File lib/prism/translation/ruby_parser.rb, line 1248 def visit_pre_execution_node(node) s(node, :iter, s(node, :preexe), 0, visit(node.statements)) end
The top-level program node.
# File lib/prism/translation/ruby_parser.rb, line 1253 def visit_program_node(node) visit(node.statements) end
0..5 ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1259 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
1r ^^
# File lib/prism/translation/ruby_parser.rb, line 1281 def visit_rational_node(node) s(node, :lit, node.value) end
redo ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1287 def visit_redo_node(node) s(node, :redo) end
/foo/ ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1293 def visit_regular_expression_node(node) s(node, :lit, Regexp.new(node.unescaped, node.options)) end
def foo(bar:); end
^^^^
# File lib/prism/translation/ruby_parser.rb, line 1299 def visit_required_keyword_parameter_node(node) s(node, :kwarg, node.name) end
def foo(bar); end
^^^
# File lib/prism/translation/ruby_parser.rb, line 1305 def visit_required_parameter_node(node) node.name end
foo rescue bar ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1311 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
begin; rescue; end
^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1317 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
def foo(*bar); end
^^^^
def foo(*); end
^
# File lib/prism/translation/ruby_parser.rb, line 1337 def visit_rest_parameter_node(node) :"*#{node.name}" end
retry ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1343 def visit_retry_node(node) s(node, :retry) end
return ^^^^^^
return 1 ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1352 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
self ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1365 def visit_self_node(node) s(node, :self) end
class << self; end ^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1376 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
__ENCODING__ ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1384 def visit_source_encoding_node(node) # TODO s(node, :colon2, s(node, :const, :Encoding), :UTF_8) end
__FILE__ ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1391 def visit_source_file_node(node) s(node, :str, node.filepath) end
__LINE__ ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1397 def visit_source_line_node(node) s(node, :lit, node.location.start_line) end
foo(*bar)
^^^^
def foo((bar, *baz)); end
^^^^
def foo(*); bar(*); end
^
# File lib/prism/translation/ruby_parser.rb, line 1409 def visit_splat_node(node) if node.expression.nil? s(node, :splat) else s(node, :splat, visit(node.expression)) end end
A list of statements.
# File lib/prism/translation/ruby_parser.rb, line 1418 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
“foo” ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1430 def visit_string_node(node) unescaped = node.unescaped if node.forced_binary_encoding? unescaped.force_encoding(Encoding::BINARY) end s(node, :str, unescaped) end
super(foo) ^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1442 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
:foo ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1456 def visit_symbol_node(node) node.value == "!@" ? s(node, :lit, :"!@") : s(node, :lit, node.unescaped.to_sym) end
true ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1462 def visit_true_node(node) s(node, :true) end
undef foo ^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1468 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
unless foo; bar end ^^^^^^^^^^^^^^^^^^^
bar unless foo ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1478 def visit_unless_node(node) s(node, :if, visit(node.predicate), visit(node.else_clause), visit(node.statements)) end
until foo; bar end ^^^^^^^^^^^^^^^^^
bar until foo ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1487 def visit_until_node(node) s(node, :until, visit(node.predicate), visit(node.statements), !node.begin_modifier?) end
case foo; when bar; end
^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1493 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
while foo; bar end ^^^^^^^^^^^^^^^^^^
bar while foo ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1502 def visit_while_node(node) s(node, :while, visit(node.predicate), visit(node.statements), !node.begin_modifier?) end
‘foo` ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1508 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
yield ^^^^^
yield 1 ^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1524 def visit_yield_node(node) s(node, :yield).concat(visit_all(node.arguments&.arguments || [])) end