class Prism::Compiler - Documentation for Ruby 3.4
Description: class Prism::Compiler: A compiler is a visitor that returns the value of each node as it visits. This is as opposed to a visitor which will only walk the tree.
Keywords: ruby,class,Prism::Compiler

# class Prism::Compiler

A compiler is a visitor that returns the value of each node as it visits. This is as opposed to a visitor which will only walk the tree. This can be useful when you are trying to compile a tree into a different format.

For example, to build a representation of the tree as s-expressions, you could write:

    class SExpressions < Prism::Compiler
      def visit_arguments_node(node) = [:arguments, super]
      def visit_call_node(node) = [:call, super]
      def visit_integer_node(node) = [:integer]
      def visit_program_node(node) = [:program, super]
    end

    Prism.parse("1 + 2").value.accept(SExpressions.new)
    # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]

### Public Instance Methods

visit (node)
Source

    # File lib/prism/compiler.rb, line 32
    def visit(node)
      node&.accept(self)
    end

Visit an individual node.

visit_alias_global_variable_node (node)
Source

    # File lib/prism/compiler.rb, line 47
    def visit_alias_global_variable_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `AliasGlobalVariableNode` node

visit_alias_method_node (node)
Source

    # File lib/prism/compiler.rb, line 52
    def visit_alias_method_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `AliasMethodNode` node

visit_all (nodes)
Source

    # File lib/prism/compiler.rb, line 37
    def visit_all(nodes)
      nodes.map { |node| node&.accept(self) }
    end

Visit a list of nodes.

visit_alternation_pattern_node (node)
Source

    # File lib/prism/compiler.rb, line 57
    def visit_alternation_pattern_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `AlternationPatternNode` node

visit_and_node (node)
Source

    # File lib/prism/compiler.rb, line 62
    def visit_and_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `AndNode` node

visit_arguments_node (node)
Source

    # File lib/prism/compiler.rb, line 67
    def visit_arguments_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ArgumentsNode` node

visit_array_node (node)
Source

    # File lib/prism/compiler.rb, line 72
    def visit_array_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ArrayNode` node

visit_array_pattern_node (node)
Source

    # File lib/prism/compiler.rb, line 77
    def visit_array_pattern_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ArrayPatternNode` node

visit_assoc_node (node)
Source

    # File lib/prism/compiler.rb, line 82
    def visit_assoc_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `AssocNode` node

visit_assoc_splat_node (node)
Source

    # File lib/prism/compiler.rb, line 87
    def visit_assoc_splat_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `AssocSplatNode` node

visit_back_reference_read_node (node)
Source

    # File lib/prism/compiler.rb, line 92
    def visit_back_reference_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BackReferenceReadNode` node

visit_begin_node (node)
Source

    # File lib/prism/compiler.rb, line 97
    def visit_begin_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BeginNode` node

visit_block_argument_node (node)
Source

    # File lib/prism/compiler.rb, line 102
    def visit_block_argument_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BlockArgumentNode` node

visit_block_local_variable_node (node)
Source

    # File lib/prism/compiler.rb, line 107
    def visit_block_local_variable_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BlockLocalVariableNode` node

visit_block_node (node)
Source

    # File lib/prism/compiler.rb, line 112
    def visit_block_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BlockNode` node

visit_block_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 117
    def visit_block_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BlockParameterNode` node

visit_block_parameters_node (node)
Source

    # File lib/prism/compiler.rb, line 122
    def visit_block_parameters_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BlockParametersNode` node

visit_break_node (node)
Source

    # File lib/prism/compiler.rb, line 127
    def visit_break_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `BreakNode` node

visit_call_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 132
    def visit_call_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CallAndWriteNode` node

visit_call_node (node)
Source

    # File lib/prism/compiler.rb, line 137
    def visit_call_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CallNode` node

visit_call_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 142
    def visit_call_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CallOperatorWriteNode` node

visit_call_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 147
    def visit_call_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CallOrWriteNode` node

visit_call_target_node (node)
Source

    # File lib/prism/compiler.rb, line 152
    def visit_call_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CallTargetNode` node

visit_capture_pattern_node (node)
Source

    # File lib/prism/compiler.rb, line 157
    def visit_capture_pattern_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CapturePatternNode` node

visit_case_match_node (node)
Source

    # File lib/prism/compiler.rb, line 162
    def visit_case_match_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CaseMatchNode` node

visit_case_node (node)
Source

    # File lib/prism/compiler.rb, line 167
    def visit_case_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `CaseNode` node

visit_child_nodes (node)
Source

    # File lib/prism/compiler.rb, line 42
    def visit_child_nodes(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Visit the child nodes of the given node.

visit_class_node (node)
Source

    # File lib/prism/compiler.rb, line 172
    def visit_class_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassNode` node

visit_class_variable_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 177
    def visit_class_variable_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassVariableAndWriteNode` node

visit_class_variable_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 182
    def visit_class_variable_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassVariableOperatorWriteNode` node

visit_class_variable_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 187
    def visit_class_variable_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassVariableOrWriteNode` node

visit_class_variable_read_node (node)
Source

    # File lib/prism/compiler.rb, line 192
    def visit_class_variable_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassVariableReadNode` node

visit_class_variable_target_node (node)
Source

    # File lib/prism/compiler.rb, line 197
    def visit_class_variable_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassVariableTargetNode` node

visit_class_variable_write_node (node)
Source

    # File lib/prism/compiler.rb, line 202
    def visit_class_variable_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ClassVariableWriteNode` node

visit_constant_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 207
    def visit_constant_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantAndWriteNode` node

visit_constant_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 212
    def visit_constant_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantOperatorWriteNode` node

visit_constant_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 217
    def visit_constant_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantOrWriteNode` node

visit_constant_path_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 222
    def visit_constant_path_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantPathAndWriteNode` node

visit_constant_path_node (node)
Source

    # File lib/prism/compiler.rb, line 227
    def visit_constant_path_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantPathNode` node

visit_constant_path_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 232
    def visit_constant_path_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantPathOperatorWriteNode` node

visit_constant_path_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 237
    def visit_constant_path_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantPathOrWriteNode` node

visit_constant_path_target_node (node)
Source

    # File lib/prism/compiler.rb, line 242
    def visit_constant_path_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantPathTargetNode` node

visit_constant_path_write_node (node)
Source

    # File lib/prism/compiler.rb, line 247
    def visit_constant_path_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantPathWriteNode` node

visit_constant_read_node (node)
Source

    # File lib/prism/compiler.rb, line 252
    def visit_constant_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantReadNode` node

visit_constant_target_node (node)
Source

    # File lib/prism/compiler.rb, line 257
    def visit_constant_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantTargetNode` node

visit_constant_write_node (node)
Source

    # File lib/prism/compiler.rb, line 262
    def visit_constant_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ConstantWriteNode` node

visit_def_node (node)
Source

    # File lib/prism/compiler.rb, line 267
    def visit_def_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `DefNode` node

visit_defined_node (node)
Source

    # File lib/prism/compiler.rb, line 272
    def visit_defined_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `DefinedNode` node

visit_else_node (node)
Source

    # File lib/prism/compiler.rb, line 277
    def visit_else_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ElseNode` node

visit_embedded_statements_node (node)
Source

    # File lib/prism/compiler.rb, line 282
    def visit_embedded_statements_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `EmbeddedStatementsNode` node

visit_embedded_variable_node (node)
Source

    # File lib/prism/compiler.rb, line 287
    def visit_embedded_variable_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `EmbeddedVariableNode` node

visit_ensure_node (node)
Source

    # File lib/prism/compiler.rb, line 292
    def visit_ensure_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `EnsureNode` node

visit_false_node (node)
Source

    # File lib/prism/compiler.rb, line 297
    def visit_false_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `FalseNode` node

visit_find_pattern_node (node)
Source

    # File lib/prism/compiler.rb, line 302
    def visit_find_pattern_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `FindPatternNode` node

visit_flip_flop_node (node)
Source

    # File lib/prism/compiler.rb, line 307
    def visit_flip_flop_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `FlipFlopNode` node

visit_float_node (node)
Source

    # File lib/prism/compiler.rb, line 312
    def visit_float_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `FloatNode` node

visit_for_node (node)
Source

    # File lib/prism/compiler.rb, line 317
    def visit_for_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ForNode` node

visit_forwarding_arguments_node (node)
Source

    # File lib/prism/compiler.rb, line 322
    def visit_forwarding_arguments_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ForwardingArgumentsNode` node

visit_forwarding_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 327
    def visit_forwarding_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ForwardingParameterNode` node

visit_forwarding_super_node (node)
Source

    # File lib/prism/compiler.rb, line 332
    def visit_forwarding_super_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ForwardingSuperNode` node

visit_global_variable_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 337
    def visit_global_variable_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `GlobalVariableAndWriteNode` node

visit_global_variable_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 342
    def visit_global_variable_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `GlobalVariableOperatorWriteNode` node

visit_global_variable_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 347
    def visit_global_variable_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `GlobalVariableOrWriteNode` node

visit_global_variable_read_node (node)
Source

    # File lib/prism/compiler.rb, line 352
    def visit_global_variable_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `GlobalVariableReadNode` node

visit_global_variable_target_node (node)
Source

    # File lib/prism/compiler.rb, line 357
    def visit_global_variable_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `GlobalVariableTargetNode` node

visit_global_variable_write_node (node)
Source

    # File lib/prism/compiler.rb, line 362
    def visit_global_variable_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `GlobalVariableWriteNode` node

visit_hash_node (node)
Source

    # File lib/prism/compiler.rb, line 367
    def visit_hash_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `HashNode` node

visit_hash_pattern_node (node)
Source

    # File lib/prism/compiler.rb, line 372
    def visit_hash_pattern_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `HashPatternNode` node

visit_if_node (node)
Source

    # File lib/prism/compiler.rb, line 377
    def visit_if_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `IfNode` node

visit_imaginary_node (node)
Source

    # File lib/prism/compiler.rb, line 382
    def visit_imaginary_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ImaginaryNode` node

visit_implicit_node (node)
Source

    # File lib/prism/compiler.rb, line 387
    def visit_implicit_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ImplicitNode` node

visit_implicit_rest_node (node)
Source

    # File lib/prism/compiler.rb, line 392
    def visit_implicit_rest_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ImplicitRestNode` node

visit_in_node (node)
Source

    # File lib/prism/compiler.rb, line 397
    def visit_in_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InNode` node

visit_index_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 402
    def visit_index_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `IndexAndWriteNode` node

visit_index_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 407
    def visit_index_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `IndexOperatorWriteNode` node

visit_index_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 412
    def visit_index_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `IndexOrWriteNode` node

visit_index_target_node (node)
Source

    # File lib/prism/compiler.rb, line 417
    def visit_index_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `IndexTargetNode` node

visit_instance_variable_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 422
    def visit_instance_variable_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InstanceVariableAndWriteNode` node

visit_instance_variable_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 427
    def visit_instance_variable_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InstanceVariableOperatorWriteNode` node

visit_instance_variable_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 432
    def visit_instance_variable_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InstanceVariableOrWriteNode` node

visit_instance_variable_read_node (node)
Source

    # File lib/prism/compiler.rb, line 437
    def visit_instance_variable_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InstanceVariableReadNode` node

visit_instance_variable_target_node (node)
Source

    # File lib/prism/compiler.rb, line 442
    def visit_instance_variable_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InstanceVariableTargetNode` node

visit_instance_variable_write_node (node)
Source

    # File lib/prism/compiler.rb, line 447
    def visit_instance_variable_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InstanceVariableWriteNode` node

visit_integer_node (node)
Source

    # File lib/prism/compiler.rb, line 452
    def visit_integer_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `IntegerNode` node

visit_interpolated_match_last_line_node (node)
Source

    # File lib/prism/compiler.rb, line 457
    def visit_interpolated_match_last_line_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InterpolatedMatchLastLineNode` node

visit_interpolated_regular_expression_node (node)
Source

    # File lib/prism/compiler.rb, line 462
    def visit_interpolated_regular_expression_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InterpolatedRegularExpressionNode` node

visit_interpolated_string_node (node)
Source

    # File lib/prism/compiler.rb, line 467
    def visit_interpolated_string_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InterpolatedStringNode` node

visit_interpolated_symbol_node (node)
Source

    # File lib/prism/compiler.rb, line 472
    def visit_interpolated_symbol_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InterpolatedSymbolNode` node

visit_interpolated_x_string_node (node)
Source

    # File lib/prism/compiler.rb, line 477
    def visit_interpolated_x_string_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `InterpolatedXStringNode` node

visit_it_local_variable_read_node (node)
Source

    # File lib/prism/compiler.rb, line 482
    def visit_it_local_variable_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ItLocalVariableReadNode` node

visit_it_parameters_node (node)
Source

    # File lib/prism/compiler.rb, line 487
    def visit_it_parameters_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ItParametersNode` node

visit_keyword_hash_node (node)
Source

    # File lib/prism/compiler.rb, line 492
    def visit_keyword_hash_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `KeywordHashNode` node

visit_keyword_rest_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 497
    def visit_keyword_rest_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `KeywordRestParameterNode` node

visit_lambda_node (node)
Source

    # File lib/prism/compiler.rb, line 502
    def visit_lambda_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LambdaNode` node

visit_local_variable_and_write_node (node)
Source

    # File lib/prism/compiler.rb, line 507
    def visit_local_variable_and_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LocalVariableAndWriteNode` node

visit_local_variable_operator_write_node (node)
Source

    # File lib/prism/compiler.rb, line 512
    def visit_local_variable_operator_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LocalVariableOperatorWriteNode` node

visit_local_variable_or_write_node (node)
Source

    # File lib/prism/compiler.rb, line 517
    def visit_local_variable_or_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LocalVariableOrWriteNode` node

visit_local_variable_read_node (node)
Source

    # File lib/prism/compiler.rb, line 522
    def visit_local_variable_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LocalVariableReadNode` node

visit_local_variable_target_node (node)
Source

    # File lib/prism/compiler.rb, line 527
    def visit_local_variable_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LocalVariableTargetNode` node

visit_local_variable_write_node (node)
Source

    # File lib/prism/compiler.rb, line 532
    def visit_local_variable_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `LocalVariableWriteNode` node

visit_match_last_line_node (node)
Source

    # File lib/prism/compiler.rb, line 537
    def visit_match_last_line_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MatchLastLineNode` node

visit_match_predicate_node (node)
Source

    # File lib/prism/compiler.rb, line 542
    def visit_match_predicate_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MatchPredicateNode` node

visit_match_required_node (node)
Source

    # File lib/prism/compiler.rb, line 547
    def visit_match_required_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MatchRequiredNode` node

visit_match_write_node (node)
Source

    # File lib/prism/compiler.rb, line 552
    def visit_match_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MatchWriteNode` node

visit_missing_node (node)
Source

    # File lib/prism/compiler.rb, line 557
    def visit_missing_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MissingNode` node

visit_module_node (node)
Source

    # File lib/prism/compiler.rb, line 562
    def visit_module_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ModuleNode` node

visit_multi_target_node (node)
Source

    # File lib/prism/compiler.rb, line 567
    def visit_multi_target_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MultiTargetNode` node

visit_multi_write_node (node)
Source

    # File lib/prism/compiler.rb, line 572
    def visit_multi_write_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `MultiWriteNode` node

visit_next_node (node)
Source

    # File lib/prism/compiler.rb, line 577
    def visit_next_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `NextNode` node

visit_nil_node (node)
Source

    # File lib/prism/compiler.rb, line 582
    def visit_nil_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `NilNode` node

visit_no_keywords_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 587
    def visit_no_keywords_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `NoKeywordsParameterNode` node

visit_numbered_parameters_node (node)
Source

    # File lib/prism/compiler.rb, line 592
    def visit_numbered_parameters_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `NumberedParametersNode` node

visit_numbered_reference_read_node (node)
Source

    # File lib/prism/compiler.rb, line 597
    def visit_numbered_reference_read_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `NumberedReferenceReadNode` node

visit_optional_keyword_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 602
    def visit_optional_keyword_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `OptionalKeywordParameterNode` node

visit_optional_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 607
    def visit_optional_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `OptionalParameterNode` node

visit_or_node (node)
Source

    # File lib/prism/compiler.rb, line 612
    def visit_or_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `OrNode` node

visit_parameters_node (node)
Source

    # File lib/prism/compiler.rb, line 617
    def visit_parameters_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ParametersNode` node

visit_parentheses_node (node)
Source

    # File lib/prism/compiler.rb, line 622
    def visit_parentheses_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ParenthesesNode` node

visit_pinned_expression_node (node)
Source

    # File lib/prism/compiler.rb, line 627
    def visit_pinned_expression_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `PinnedExpressionNode` node

visit_pinned_variable_node (node)
Source

    # File lib/prism/compiler.rb, line 632
    def visit_pinned_variable_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `PinnedVariableNode` node

visit_post_execution_node (node)
Source

    # File lib/prism/compiler.rb, line 637
    def visit_post_execution_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `PostExecutionNode` node

visit_pre_execution_node (node)
Source

    # File lib/prism/compiler.rb, line 642
    def visit_pre_execution_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `PreExecutionNode` node

visit_program_node (node)
Source

    # File lib/prism/compiler.rb, line 647
    def visit_program_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ProgramNode` node

visit_range_node (node)
Source

    # File lib/prism/compiler.rb, line 652
    def visit_range_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RangeNode` node

visit_rational_node (node)
Source

    # File lib/prism/compiler.rb, line 657
    def visit_rational_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RationalNode` node

visit_redo_node (node)
Source

    # File lib/prism/compiler.rb, line 662
    def visit_redo_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RedoNode` node

visit_regular_expression_node (node)
Source

    # File lib/prism/compiler.rb, line 667
    def visit_regular_expression_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RegularExpressionNode` node

visit_required_keyword_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 672
    def visit_required_keyword_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RequiredKeywordParameterNode` node

visit_required_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 677
    def visit_required_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RequiredParameterNode` node

visit_rescue_modifier_node (node)
Source

    # File lib/prism/compiler.rb, line 682
    def visit_rescue_modifier_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RescueModifierNode` node

visit_rescue_node (node)
Source

    # File lib/prism/compiler.rb, line 687
    def visit_rescue_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RescueNode` node

visit_rest_parameter_node (node)
Source

    # File lib/prism/compiler.rb, line 692
    def visit_rest_parameter_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RestParameterNode` node

visit_retry_node (node)
Source

    # File lib/prism/compiler.rb, line 697
    def visit_retry_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `RetryNode` node

visit_return_node (node)
Source

    # File lib/prism/compiler.rb, line 702
    def visit_return_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ReturnNode` node

visit_self_node (node)
Source

    # File lib/prism/compiler.rb, line 707
    def visit_self_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SelfNode` node

visit_shareable_constant_node (node)
Source

    # File lib/prism/compiler.rb, line 712
    def visit_shareable_constant_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `ShareableConstantNode` node

visit_singleton_class_node (node)
Source

    # File lib/prism/compiler.rb, line 717
    def visit_singleton_class_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SingletonClassNode` node

visit_source_encoding_node (node)
Source

    # File lib/prism/compiler.rb, line 722
    def visit_source_encoding_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SourceEncodingNode` node

visit_source_file_node (node)
Source

    # File lib/prism/compiler.rb, line 727
    def visit_source_file_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SourceFileNode` node

visit_source_line_node (node)
Source

    # File lib/prism/compiler.rb, line 732
    def visit_source_line_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SourceLineNode` node

visit_splat_node (node)
Source

    # File lib/prism/compiler.rb, line 737
    def visit_splat_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SplatNode` node

visit_statements_node (node)
Source

    # File lib/prism/compiler.rb, line 742
    def visit_statements_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `StatementsNode` node

visit_string_node (node)
Source

    # File lib/prism/compiler.rb, line 747
    def visit_string_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `StringNode` node

visit_super_node (node)
Source

    # File lib/prism/compiler.rb, line 752
    def visit_super_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SuperNode` node

visit_symbol_node (node)
Source

    # File lib/prism/compiler.rb, line 757
    def visit_symbol_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `SymbolNode` node

visit_true_node (node)
Source

    # File lib/prism/compiler.rb, line 762
    def visit_true_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `TrueNode` node

visit_undef_node (node)
Source

    # File lib/prism/compiler.rb, line 767
    def visit_undef_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `UndefNode` node

visit_unless_node (node)
Source

    # File lib/prism/compiler.rb, line 772
    def visit_unless_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `UnlessNode` node

visit_until_node (node)
Source

    # File lib/prism/compiler.rb, line 777
    def visit_until_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `UntilNode` node

visit_when_node (node)
Source

    # File lib/prism/compiler.rb, line 782
    def visit_when_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `WhenNode` node

visit_while_node (node)
Source

    # File lib/prism/compiler.rb, line 787
    def visit_while_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `WhileNode` node

visit_x_string_node (node)
Source

    # File lib/prism/compiler.rb, line 792
    def visit_x_string_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `XStringNode` node

visit_yield_node (node)
Source

    # File lib/prism/compiler.rb, line 797
    def visit_yield_node(node)
      node.compact_child_nodes.map { |node| node.accept(self) }
    end

Compile a `YieldNode` node