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 26 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 40 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 34 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 46 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 52 def visit_and_node(node) s(node, :and, visit(node.left), visit(node.right)) end
foo(bar)
^^^
# File lib/prism/translation/ruby_parser.rb, line 91 def visit_arguments_node(node) raise "Cannot visit arguments directly" end
-
^^
# File lib/prism/translation/ruby_parser.rb, line 58 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 68 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 97 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 106 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 116 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 122 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.consequent).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 155 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 163 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 168 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 174 def visit_block_parameter_node(node) :"&#{node.name}" end
A block’s parameters.
# File lib/prism/translation/ruby_parser.rb, line 179 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 219 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 282 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 237 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 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 272 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.operator) else s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.operator, visit_write_value(node.value)) end end
foo.bar ||= baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 292 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 315 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 321 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 333 def visit_case_match_node(node) s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.consequent) end
case foo; when bar; end ^^^^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 327 def visit_case_node(node) s(node, :case, visit(node.predicate)).concat(visit_all(node.conditions)) << visit(node.consequent) end
class Foo; end ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 339 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 380 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 374 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.operator, visit_write_value(node.value))) end
@@foo ||= bar ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 386 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 359 def visit_class_variable_read_node(node) s(node, :cvar, node.name) end
@@foo, = bar ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 392 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 368 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 425 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 419 def visit_constant_operator_write_node(node) s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.operator, visit_write_value(node.value))) end
Foo ||= bar ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 431 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 468 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 443 def visit_constant_path_node(node) if node.parent.nil? s(node, :colon3, node.child.name) else s(node, :colon2, visit(node.parent), node.child.name) end end
Foo::Bar += baz ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 462 def visit_constant_path_operator_write_node(node) s(node, :op_asgn, visit(node.target), node.operator, visit_write_value(node.value)) end
Foo::Bar ||= baz ^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 474 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 480 def visit_constant_path_target_node(node) inner = if node.parent.nil? s(node, :colon3, node.child.name) else s(node, :colon2, visit(node.parent), node.child.name) end s(node, :const, inner) end
Foo::Bar = 1 ^^^^^^^^^^^^
Foo::Foo, Bar::Bar = 1 ^^^^^^^^ ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 456 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 404 def visit_constant_read_node(node) s(node, :const, node.name) end
Foo, = bar ^^^
# File lib/prism/translation/ruby_parser.rb, line 437 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 413 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 496 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 527 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 533 def visit_else_node(node) visit(node.statements) end
“foo #{bar}”
^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 539 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 547 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 553 def visit_ensure_node(node) node.statements.nil? ? s(node, :nil) : visit(node.statements) end
false ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 559 def visit_false_node(node) s(node, :false) end
foo => [*, bar, *]
^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 565 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 571 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 581 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 587 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 593 def visit_forwarding_arguments_node(node) s(node, :forward_args) end
def foo(…); end
^^^
# File lib/prism/translation/ruby_parser.rb, line 599 def visit_forwarding_parameter_node(node) s(node, :forward_args) end
super ^^^^^
super {} ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 608 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 635 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 629 def visit_global_variable_operator_write_node(node) s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.operator, visit(node.value))) end
$foo ||= bar ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 641 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 614 def visit_global_variable_read_node(node) s(node, :gvar, node.name) end
$foo, = bar ^^^^
# File lib/prism/translation/ruby_parser.rb, line 647 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 623 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 653 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 659 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 680 def visit_if_node(node) s(node, :if, visit(node.predicate), visit(node.statements), visit(node.consequent)) end
1i
# File lib/prism/translation/ruby_parser.rb, line 685 def visit_imaginary_node(node) s(node, :lit, node.value) end
{ foo: }
^^^^
# File lib/prism/translation/ruby_parser.rb, line 691 def visit_implicit_node(node) end
foo { |bar,| }
^
# File lib/prism/translation/ruby_parser.rb, line 696 def visit_implicit_rest_node(node) end
case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 701 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 727 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 714 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.operator, visit_write_value(node.value)) end
foo ||= baz ^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 740 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 753 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 783 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 777 def visit_instance_variable_operator_write_node(node) s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.operator, visit_write_value(node.value))) end
@foo ||= bar ^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 789 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 762 def visit_instance_variable_read_node(node) s(node, :ivar, node.name) end
@foo, = bar ^^^^
# File lib/prism/translation/ruby_parser.rb, line 795 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 771 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 801 def visit_integer_node(node) s(node, :lit, node.value) end
if /foo #{bar}/ then end
^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 807 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 824 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 839 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 846 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 853 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: baz)
^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 911 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 920 def visit_keyword_rest_parameter_node(node) :"**#{node.name}" end
-> {}
# File lib/prism/translation/ruby_parser.rb, line 925 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 968 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 962 def visit_local_variable_operator_write_node(node) s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.operator, visit_write_value(node.value))) end
foo ||= bar ^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 974 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 943 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 980 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 956 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 986 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 992 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 998 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 1004 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 1011 def visit_missing_node(node) raise "Cannot visit missing node directly" end
module Foo; end ^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1017 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 1037 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 1047 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 1071 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 1084 def visit_nil_node(node) s(node, :nil) end
def foo(**nil); end
^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1090 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 1096 def visit_numbered_parameters_node(node) raise "Cannot visit numbered parameters directly" end
$1 ^^
# File lib/prism/translation/ruby_parser.rb, line 1102 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 1108 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 1114 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 1120 def visit_or_node(node) s(node, :or, visit(node.left), visit(node.right)) end
def foo(bar, *baz); end
^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1126 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 1164 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 1174 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 1180 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 1189 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 1194 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 1199 def visit_program_node(node) visit(node.statements) end
0..5 ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1205 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 1227 def visit_rational_node(node) s(node, :lit, node.value) end
redo ^^^^
# File lib/prism/translation/ruby_parser.rb, line 1233 def visit_redo_node(node) s(node, :redo) end
/foo/ ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1239 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 1245 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 1251 def visit_required_parameter_node(node) node.name end
foo rescue bar ^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1257 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 1263 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 1283 def visit_rest_parameter_node(node) :"*#{node.name}" end
retry ^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1289 def visit_retry_node(node) s(node, :retry) end
return ^^^^^^
return 1 ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1298 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 1311 def visit_self_node(node) s(node, :self) end
class << self; end ^^^^^^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1322 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 1330 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 1337 def visit_source_file_node(node) s(node, :str, node.filepath) end
__LINE__ ^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1343 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 1355 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 1364 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 1376 def visit_string_node(node) s(node, :str, node.unescaped) end
super(foo) ^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1382 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 1396 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 1402 def visit_true_node(node) s(node, :true) end
undef foo ^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1408 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 1418 def visit_unless_node(node) s(node, :if, visit(node.predicate), visit(node.consequent), visit(node.statements)) end
until foo; bar end ^^^^^^^^^^^^^^^^^
bar until foo ^^^^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1427 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 1433 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 1442 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 1448 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 1464 def visit_yield_node(node) s(node, :yield).concat(visit_all(node.arguments&.arguments || [])) end
Private Instance Methods
If a class variable is written within a method definition, it has a different type than everywhere else.
# File lib/prism/translation/ruby_parser.rb, line 398 def class_variable_write_type in_def ? :cvasgn : :cvdecl end
Create a new compiler with the given options.
# File lib/prism/translation/ruby_parser.rb, line 1471 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
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.
# File lib/prism/translation/ruby_parser.rb, line 303 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 can use &. as an operator, which changes their type by prefixing “safe_”.
# File lib/prism/translation/ruby_parser.rb, line 309 def op_asgn_type(node, type) node.safe_navigation? ? :"safe_#{type}" : type end
Create a new Sexp object from the given prism node and arguments.
# File lib/prism/translation/ruby_parser.rb, line 1476 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
Visit a block node, which will modify the AST by wrapping the given visited node in an iter node.
# File lib/prism/translation/ruby_parser.rb, line 1486 def visit_block(node, sexp, block) if block.nil? sexp else parameters = case block.parameters when nil, 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
def foo((bar, baz)); end
^^^^^^^^^^
# File lib/prism/translation/ruby_parser.rb, line 1141 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
Visit the interpolated content of the string-like node.
# File lib/prism/translation/ruby_parser.rb, line 860 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 else visited << result end end state = :beginning #: :beginning | :string_content | :interpolated_content visited.each_with_object([]) do |result, results| 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.is_a?(String) results[0] << result elsif result.is_a?(Array) && result[0] == :str results[0] << result[1] else results << result state = :interpolated_content end else results << result end end end
Pattern
constants get wrapped in another layer of :const.
# File lib/prism/translation/ruby_parser.rb, line 1507 def visit_pattern_constant(node) case node when nil # nothing when ConstantReadNode visit(node) else s(node, :const, 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).
# File lib/prism/translation/ruby_parser.rb, line 1217 def visit_range_bounds_node(node) if node.is_a?(ParenthesesNode) && node.body.nil? s(node, :begin) 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.
# File lib/prism/translation/ruby_parser.rb, line 1521 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