Spec-Zone.ru › Ruby 3.3

class Prism::Dispatcher

Parent:
Visitor

Класс-диспетчер генерирует события для узлов, которые находятся во время обхода АСТ, всем зарегистрированным слушателям. Он полезен для выполнения различных типов анализа АСТ, при этом нужно пройтись по дереву только один раз.

Чтобы использовать диспетчер, вы сначала инициализируете его и регистрируете слушателей для интересующих вас событий:

class OctalListener
  def on_integer_node_enter(node)
    if node.octal? && !node.slice.start_with?("0o")
      warn("Octal integers should be written with the 0o prefix")
    end
  end
end

dispatcher = Dispatcher.new
dispatcher.register(listener, :on_integer_node_enter)

Затем вы можете пройти любое количество деревьев и отправить события слушателям:

result = Prism.parse("001 + 002 + 003")
dispatcher.dispatch(result.value)

По желанию, вы также можете использовать «#dispatch_once`, чтобы отправить события входа и выхода для отдельного узла без рекурсивного обхода дальше по дереву. Это может быть полезно в ситуациях, когда вы хотите повторно использовать уже зарегистрированных слушателей, но хотите остановить обход дерева на определённом моменте.

integer = result.value.statements.body.first.receiver.receiver
dispatcher.dispatch_once(integer)

Атрибуты

listeners[R]

attr_reader listeners: Hash[Symbol, Array]

Открытые методы класса

new() Показать исходный код
# File lib/prism/dispatcher.rb, line 45
def initialize
  @listeners = {}
end

Инициализировать новый диспетчер.

Публичные методы экземпляра

dispatch_once(node) Show source
# File lib/prism/dispatcher.rb, line 64
def dispatch_once(node)
  node.accept(DispatchOnce.new(listeners))
end

Отправляет одно событие для ‘node` всем зарегистрированным слушателям.

def dispatch_once: (Node) -> void

register(listener, *events) Show source
# File lib/prism/dispatcher.rb, line 52
def register(listener, *events)
  events.each { |event| (listeners[event] ||= []) << listener }
end

Регистрирует слушателя для одного или нескольких событий.

def register: (Listener, *Symbol) -> void

visit_alias_global_variable_node(node) Show source
# File lib/prism/dispatcher.rb, line 70
def visit_alias_global_variable_node(node)
  listeners[:on_alias_global_variable_node_enter]&.each { |listener| listener.on_alias_global_variable_node_enter(node) }
  super
  listeners[:on_alias_global_variable_node_leave]&.each { |listener| listener.on_alias_global_variable_node_leave(node) }
end

Отправляет события входа и выхода для узлов AliasGlobalVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_alias_method_node(node) Show source
# File lib/prism/dispatcher.rb, line 78
def visit_alias_method_node(node)
  listeners[:on_alias_method_node_enter]&.each { |listener| listener.on_alias_method_node_enter(node) }
  super
  listeners[:on_alias_method_node_leave]&.each { |listener| listener.on_alias_method_node_leave(node) }
end

Отправляет события входа и выхода для узлов AliasMethodNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_alternation_pattern_node(node) Show source
# File lib/prism/dispatcher.rb, line 86
def visit_alternation_pattern_node(node)
  listeners[:on_alternation_pattern_node_enter]&.each { |listener| listener.on_alternation_pattern_node_enter(node) }
  super
  listeners[:on_alternation_pattern_node_leave]&.each { |listener| listener.on_alternation_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов AlternationPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_and_node(node) Show source
# File lib/prism/dispatcher.rb, line 94
def visit_and_node(node)
  listeners[:on_and_node_enter]&.each { |listener| listener.on_and_node_enter(node) }
  super
  listeners[:on_and_node_leave]&.each { |listener| listener.on_and_node_leave(node) }
end

Отправляет события входа и выхода для узлов AndNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_arguments_node(node) Show source
# File lib/prism/dispatcher.rb, line 102
def visit_arguments_node(node)
  listeners[:on_arguments_node_enter]&.each { |listener| listener.on_arguments_node_enter(node) }
  super
  listeners[:on_arguments_node_leave]&.each { |listener| listener.on_arguments_node_leave(node) }
end

Отправляет события входа и выхода для узлов ArgumentsNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_array_node(node) Show source
# File lib/prism/dispatcher.rb, line 110
def visit_array_node(node)
  listeners[:on_array_node_enter]&.each { |listener| listener.on_array_node_enter(node) }
  super
  listeners[:on_array_node_leave]&.each { |listener| listener.on_array_node_leave(node) }
end

Отправляет события входа и выхода для узлов ArrayNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_array_pattern_node(node) Show source
# File lib/prism/dispatcher.rb, line 118
def visit_array_pattern_node(node)
  listeners[:on_array_pattern_node_enter]&.each { |listener| listener.on_array_pattern_node_enter(node) }
  super
  listeners[:on_array_pattern_node_leave]&.each { |listener| listener.on_array_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов ArrayPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_assoc_node(node) Show source
# File lib/prism/dispatcher.rb, line 126
def visit_assoc_node(node)
  listeners[:on_assoc_node_enter]&.each { |listener| listener.on_assoc_node_enter(node) }
  super
  listeners[:on_assoc_node_leave]&.each { |listener| listener.on_assoc_node_leave(node) }
end

Отправляет события входа и выхода для узлов AssocNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_assoc_splat_node(node) Show source
# File lib/prism/dispatcher.rb, line 134
def visit_assoc_splat_node(node)
  listeners[:on_assoc_splat_node_enter]&.each { |listener| listener.on_assoc_splat_node_enter(node) }
  super
  listeners[:on_assoc_splat_node_leave]&.each { |listener| listener.on_assoc_splat_node_leave(node) }
end

Отправляет события входа и выхода для узлов AssocSplatNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_back_reference_read_node(node) Show source
# File lib/prism/dispatcher.rb, line 142
def visit_back_reference_read_node(node)
  listeners[:on_back_reference_read_node_enter]&.each { |listener| listener.on_back_reference_read_node_enter(node) }
  super
  listeners[:on_back_reference_read_node_leave]&.each { |listener| listener.on_back_reference_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов BackReferenceReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_begin_node(node) Show source
# File lib/prism/dispatcher.rb, line 150
def visit_begin_node(node)
  listeners[:on_begin_node_enter]&.each { |listener| listener.on_begin_node_enter(node) }
  super
  listeners[:on_begin_node_leave]&.each { |listener| listener.on_begin_node_leave(node) }
end

Отправляет события входа и выхода для узлов BeginNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_argument_node(node) Show source
# File lib/prism/dispatcher.rb, line 158
def visit_block_argument_node(node)
  listeners[:on_block_argument_node_enter]&.each { |listener| listener.on_block_argument_node_enter(node) }
  super
  listeners[:on_block_argument_node_leave]&.each { |listener| listener.on_block_argument_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockArgumentNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_local_variable_node(node) Show source
# File lib/prism/dispatcher.rb, line 166
def visit_block_local_variable_node(node)
  listeners[:on_block_local_variable_node_enter]&.each { |listener| listener.on_block_local_variable_node_enter(node) }
  super
  listeners[:on_block_local_variable_node_leave]&.each { |listener| listener.on_block_local_variable_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockLocalVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_node(node) Show source
# File lib/prism/dispatcher.rb, line 174
def visit_block_node(node)
  listeners[:on_block_node_enter]&.each { |listener| listener.on_block_node_enter(node) }
  super
  listeners[:on_block_node_leave]&.each { |listener| listener.on_block_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_parameter_node(node) Show source
# File lib/prism/dispatcher.rb, line 182
def visit_block_parameter_node(node)
  listeners[:on_block_parameter_node_enter]&.each { |listener| listener.on_block_parameter_node_enter(node) }
  super
  listeners[:on_block_parameter_node_leave]&.each { |listener| listener.on_block_parameter_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockParameterNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_block_parameters_node(node) Show source
# File lib/prism/dispatcher.rb, line 190
def visit_block_parameters_node(node)
  listeners[:on_block_parameters_node_enter]&.each { |listener| listener.on_block_parameters_node_enter(node) }
  super
  listeners[:on_block_parameters_node_leave]&.each { |listener| listener.on_block_parameters_node_leave(node) }
end

Отправляет события входа и выхода для узлов BlockParametersNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_break_node(node) Show source
# File lib/prism/dispatcher.rb, line 198
def visit_break_node(node)
  listeners[:on_break_node_enter]&.each { |listener| listener.on_break_node_enter(node) }
  super
  listeners[:on_break_node_leave]&.each { |listener| listener.on_break_node_leave(node) }
end

Отправляет события входа и выхода для узлов BreakNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_call_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 206
def visit_call_and_write_node(node)
  listeners[:on_call_and_write_node_enter]&.each { |listener| listener.on_call_and_write_node_enter(node) }
  super
  listeners[:on_call_and_write_node_leave]&.each { |listener| listener.on_call_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов CallAndWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_call_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 214
def visit_call_node(node)
  listeners[:on_call_node_enter]&.each { |listener| listener.on_call_node_enter(node) }
  super
  listeners[:on_call_node_leave]&.each { |listener| listener.on_call_node_leave(node) }
end

Отправить события входа и выхода для узлов CallNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_call_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 222
def visit_call_operator_write_node(node)
  listeners[:on_call_operator_write_node_enter]&.each { |listener| listener.on_call_operator_write_node_enter(node) }
  super
  listeners[:on_call_operator_write_node_leave]&.each { |listener| listener.on_call_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов CallOperatorWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_call_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 230
def visit_call_or_write_node(node)
  listeners[:on_call_or_write_node_enter]&.each { |listener| listener.on_call_or_write_node_enter(node) }
  super
  listeners[:on_call_or_write_node_leave]&.each { |listener| listener.on_call_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов CallOrWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_call_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 238
def visit_call_target_node(node)
  listeners[:on_call_target_node_enter]&.each { |listener| listener.on_call_target_node_enter(node) }
  super
  listeners[:on_call_target_node_leave]&.each { |listener| listener.on_call_target_node_leave(node) }
end

Отправить события входа и выхода для узлов CallTargetNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_capture_pattern_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 246
def visit_capture_pattern_node(node)
  listeners[:on_capture_pattern_node_enter]&.each { |listener| listener.on_capture_pattern_node_enter(node) }
  super
  listeners[:on_capture_pattern_node_leave]&.each { |listener| listener.on_capture_pattern_node_leave(node) }
end

Отправить события входа и выхода для узлов CapturePatternNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_case_match_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 254
def visit_case_match_node(node)
  listeners[:on_case_match_node_enter]&.each { |listener| listener.on_case_match_node_enter(node) }
  super
  listeners[:on_case_match_node_leave]&.each { |listener| listener.on_case_match_node_leave(node) }
end

Отправить события входа и выхода для узлов CaseMatchNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_case_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 262
def visit_case_node(node)
  listeners[:on_case_node_enter]&.each { |listener| listener.on_case_node_enter(node) }
  super
  listeners[:on_case_node_leave]&.each { |listener| listener.on_case_node_leave(node) }
end

Отправить события входа и выхода для узлов CaseNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 270
def visit_class_node(node)
  listeners[:on_class_node_enter]&.each { |listener| listener.on_class_node_enter(node) }
  super
  listeners[:on_class_node_leave]&.each { |listener| listener.on_class_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_variable_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 278
def visit_class_variable_and_write_node(node)
  listeners[:on_class_variable_and_write_node_enter]&.each { |listener| listener.on_class_variable_and_write_node_enter(node) }
  super
  listeners[:on_class_variable_and_write_node_leave]&.each { |listener| listener.on_class_variable_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassVariableAndWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_variable_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 286
def visit_class_variable_operator_write_node(node)
  listeners[:on_class_variable_operator_write_node_enter]&.each { |listener| listener.on_class_variable_operator_write_node_enter(node) }
  super
  listeners[:on_class_variable_operator_write_node_leave]&.each { |listener| listener.on_class_variable_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassVariableOperatorWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_variable_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 294
def visit_class_variable_or_write_node(node)
  listeners[:on_class_variable_or_write_node_enter]&.each { |listener| listener.on_class_variable_or_write_node_enter(node) }
  super
  listeners[:on_class_variable_or_write_node_leave]&.each { |listener| listener.on_class_variable_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassVariableOrWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_variable_read_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 302
def visit_class_variable_read_node(node)
  listeners[:on_class_variable_read_node_enter]&.each { |listener| listener.on_class_variable_read_node_enter(node) }
  super
  listeners[:on_class_variable_read_node_leave]&.each { |listener| listener.on_class_variable_read_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassVariableReadNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_variable_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 310
def visit_class_variable_target_node(node)
  listeners[:on_class_variable_target_node_enter]&.each { |listener| listener.on_class_variable_target_node_enter(node) }
  super
  listeners[:on_class_variable_target_node_leave]&.each { |listener| listener.on_class_variable_target_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassVariableTargetNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_class_variable_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 318
def visit_class_variable_write_node(node)
  listeners[:on_class_variable_write_node_enter]&.each { |listener| listener.on_class_variable_write_node_enter(node) }
  super
  listeners[:on_class_variable_write_node_leave]&.each { |listener| listener.on_class_variable_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ClassVariableWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_constant_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 326
def visit_constant_and_write_node(node)
  listeners[:on_constant_and_write_node_enter]&.each { |listener| listener.on_constant_and_write_node_enter(node) }
  super
  listeners[:on_constant_and_write_node_leave]&.each { |listener| listener.on_constant_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ConstantAndWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_constant_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 334
def visit_constant_operator_write_node(node)
  listeners[:on_constant_operator_write_node_enter]&.each { |listener| listener.on_constant_operator_write_node_enter(node) }
  super
  listeners[:on_constant_operator_write_node_leave]&.each { |listener| listener.on_constant_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ConstantOperatorWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_constant_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 342
def visit_constant_or_write_node(node)
  listeners[:on_constant_or_write_node_enter]&.each { |listener| listener.on_constant_or_write_node_enter(node) }
  super
  listeners[:on_constant_or_write_node_leave]&.each { |listener| listener.on_constant_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов ConstantOrWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_constant_path_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 350
def visit_constant_path_and_write_node(node)
  listeners[:on_constant_path_and_write_node_enter]&.each { |listener| listener.on_constant_path_and_write_node_enter(node) }
  super
  listeners[:on_constant_path_and_write_node_leave]&.each { |listener| listener.on_constant_path_and_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathAndWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 358
def visit_constant_path_node(node)
  listeners[:on_constant_path_node_enter]&.each { |listener| listener.on_constant_path_node_enter(node) }
  super
  listeners[:on_constant_path_node_leave]&.each { |listener| listener.on_constant_path_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 366
def visit_constant_path_operator_write_node(node)
  listeners[:on_constant_path_operator_write_node_enter]&.each { |listener| listener.on_constant_path_operator_write_node_enter(node) }
  super
  listeners[:on_constant_path_operator_write_node_leave]&.each { |listener| listener.on_constant_path_operator_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathOperatorWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 374
def visit_constant_path_or_write_node(node)
  listeners[:on_constant_path_or_write_node_enter]&.each { |listener| listener.on_constant_path_or_write_node_enter(node) }
  super
  listeners[:on_constant_path_or_write_node_leave]&.each { |listener| listener.on_constant_path_or_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathOrWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 382
def visit_constant_path_target_node(node)
  listeners[:on_constant_path_target_node_enter]&.each { |listener| listener.on_constant_path_target_node_enter(node) }
  super
  listeners[:on_constant_path_target_node_leave]&.each { |listener| listener.on_constant_path_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_path_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 390
def visit_constant_path_write_node(node)
  listeners[:on_constant_path_write_node_enter]&.each { |listener| listener.on_constant_path_write_node_enter(node) }
  super
  listeners[:on_constant_path_write_node_leave]&.each { |listener| listener.on_constant_path_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantPathWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_read_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 398
def visit_constant_read_node(node)
  listeners[:on_constant_read_node_enter]&.each { |listener| listener.on_constant_read_node_enter(node) }
  super
  listeners[:on_constant_read_node_leave]&.each { |listener| listener.on_constant_read_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantReadNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 406
def visit_constant_target_node(node)
  listeners[:on_constant_target_node_enter]&.each { |listener| listener.on_constant_target_node_enter(node) }
  super
  listeners[:on_constant_target_node_leave]&.each { |listener| listener.on_constant_target_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantTargetNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_constant_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 414
def visit_constant_write_node(node)
  listeners[:on_constant_write_node_enter]&.each { |listener| listener.on_constant_write_node_enter(node) }
  super
  listeners[:on_constant_write_node_leave]&.each { |listener| listener.on_constant_write_node_leave(node) }
end

Отправляет события входа и выхода для узлов ConstantWriteNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_def_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 422
def visit_def_node(node)
  listeners[:on_def_node_enter]&.each { |listener| listener.on_def_node_enter(node) }
  super
  listeners[:on_def_node_leave]&.each { |listener| listener.on_def_node_leave(node) }
end

Отправляет события входа и выхода для узлов DefNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_defined_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 430
def visit_defined_node(node)
  listeners[:on_defined_node_enter]&.each { |listener| listener.on_defined_node_enter(node) }
  super
  listeners[:on_defined_node_leave]&.each { |listener| listener.on_defined_node_leave(node) }
end

Отправляет события входа и выхода для узлов DefinedNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_else_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 438
def visit_else_node(node)
  listeners[:on_else_node_enter]&.each { |listener| listener.on_else_node_enter(node) }
  super
  listeners[:on_else_node_leave]&.each { |listener| listener.on_else_node_leave(node) }
end

Отправляет события входа и выхода для узлов ElseNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_embedded_statements_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 446
def visit_embedded_statements_node(node)
  listeners[:on_embedded_statements_node_enter]&.each { |listener| listener.on_embedded_statements_node_enter(node) }
  super
  listeners[:on_embedded_statements_node_leave]&.each { |listener| listener.on_embedded_statements_node_leave(node) }
end

Отправляет события входа и выхода для узлов EmbeddedStatementsNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_embedded_variable_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 454
def visit_embedded_variable_node(node)
  listeners[:on_embedded_variable_node_enter]&.each { |listener| listener.on_embedded_variable_node_enter(node) }
  super
  listeners[:on_embedded_variable_node_leave]&.each { |listener| listener.on_embedded_variable_node_leave(node) }
end

Отправляет события входа и выхода для узлов EmbeddedVariableNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_ensure_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 462
def visit_ensure_node(node)
  listeners[:on_ensure_node_enter]&.each { |listener| listener.on_ensure_node_enter(node) }
  super
  listeners[:on_ensure_node_leave]&.each { |listener| listener.on_ensure_node_leave(node) }
end

Отправляет события входа и выхода для узлов EnsureNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_false_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 470
def visit_false_node(node)
  listeners[:on_false_node_enter]&.each { |listener| listener.on_false_node_enter(node) }
  super
  listeners[:on_false_node_leave]&.each { |listener| listener.on_false_node_leave(node) }
end

Отправляет события входа и выхода для узлов FalseNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_find_pattern_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 478
def visit_find_pattern_node(node)
  listeners[:on_find_pattern_node_enter]&.each { |listener| listener.on_find_pattern_node_enter(node) }
  super
  listeners[:on_find_pattern_node_leave]&.each { |listener| listener.on_find_pattern_node_leave(node) }
end

Отправляет события входа и выхода для узлов FindPatternNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_flip_flop_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 486
def visit_flip_flop_node(node)
  listeners[:on_flip_flop_node_enter]&.each { |listener| listener.on_flip_flop_node_enter(node) }
  super
  listeners[:on_flip_flop_node_leave]&.each { |listener| listener.on_flip_flop_node_leave(node) }
end

Отправляет события входа и выхода для узлов FlipFlopNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_float_node(node) Show source
# File lib/prism/dispatcher.rb, line 494
def visit_float_node(node)
  listeners[:on_float_node_enter]&.each { |listener| listener.on_float_node_enter(node) }
  super
  listeners[:on_float_node_leave]&.each { |listener| listener.on_float_node_leave(node) }
end

Отправить события входа и выхода для узлов FloatNode и продолжить обход дерева.

Calls superclass method
visit_for_node(node) Show source
# File lib/prism/dispatcher.rb, line 502
def visit_for_node(node)
  listeners[:on_for_node_enter]&.each { |listener| listener.on_for_node_enter(node) }
  super
  listeners[:on_for_node_leave]&.each { |listener| listener.on_for_node_leave(node) }
end

Отправить события входа и выхода для узлов ForNode и продолжить обход дерева.

Calls superclass method
visit_forwarding_arguments_node(node) Show source
# File lib/prism/dispatcher.rb, line 510
def visit_forwarding_arguments_node(node)
  listeners[:on_forwarding_arguments_node_enter]&.each { |listener| listener.on_forwarding_arguments_node_enter(node) }
  super
  listeners[:on_forwarding_arguments_node_leave]&.each { |listener| listener.on_forwarding_arguments_node_leave(node) }
end

Отправить события входа и выхода для узлов ForwardingArgumentsNode и продолжить обход дерева.

Calls superclass method
visit_forwarding_parameter_node(node) Show source
# File lib/prism/dispatcher.rb, line 518
def visit_forwarding_parameter_node(node)
  listeners[:on_forwarding_parameter_node_enter]&.each { |listener| listener.on_forwarding_parameter_node_enter(node) }
  super
  listeners[:on_forwarding_parameter_node_leave]&.each { |listener| listener.on_forwarding_parameter_node_leave(node) }
end

Отправить события входа и выхода для узлов ForwardingParameterNode и продолжить обход дерева.

Calls superclass method
visit_forwarding_super_node(node) Show source
# File lib/prism/dispatcher.rb, line 526
def visit_forwarding_super_node(node)
  listeners[:on_forwarding_super_node_enter]&.each { |listener| listener.on_forwarding_super_node_enter(node) }
  super
  listeners[:on_forwarding_super_node_leave]&.each { |listener| listener.on_forwarding_super_node_leave(node) }
end

Отправить события входа и выхода для узлов ForwardingSuperNode и продолжить обход дерева.

Calls superclass method
visit_global_variable_and_write_node(node) Show source
# File lib/prism/dispatcher.rb, line 534
def visit_global_variable_and_write_node(node)
  listeners[:on_global_variable_and_write_node_enter]&.each { |listener| listener.on_global_variable_and_write_node_enter(node) }
  super
  listeners[:on_global_variable_and_write_node_leave]&.each { |listener| listener.on_global_variable_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов GlobalVariableAndWriteNode и продолжить обход дерева.

Calls superclass method
visit_global_variable_operator_write_node(node) Show source
# File lib/prism/dispatcher.rb, line 542
def visit_global_variable_operator_write_node(node)
  listeners[:on_global_variable_operator_write_node_enter]&.each { |listener| listener.on_global_variable_operator_write_node_enter(node) }
  super
  listeners[:on_global_variable_operator_write_node_leave]&.each { |listener| listener.on_global_variable_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов GlobalVariableOperatorWriteNode и продолжить обход дерева.

Calls superclass method
visit_global_variable_or_write_node(node) Show source
# File lib/prism/dispatcher.rb, line 550
def visit_global_variable_or_write_node(node)
  listeners[:on_global_variable_or_write_node_enter]&.each { |listener| listener.on_global_variable_or_write_node_enter(node) }
  super
  listeners[:on_global_variable_or_write_node_leave]&.each { |listener| listener.on_global_variable_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов GlobalVariableOrWriteNode и продолжить обход дерева.

Calls superclass method
visit_global_variable_read_node(node) Show source
# File lib/prism/dispatcher.rb, line 558
def visit_global_variable_read_node(node)
  listeners[:on_global_variable_read_node_enter]&.each { |listener| listener.on_global_variable_read_node_enter(node) }
  super
  listeners[:on_global_variable_read_node_leave]&.each { |listener| listener.on_global_variable_read_node_leave(node) }
end

Отправить события входа и выхода для узлов GlobalVariableReadNode и продолжить обход дерева.

Calls superclass method
visit_global_variable_target_node(node) Show source
# File lib/prism/dispatcher.rb, line 566
def visit_global_variable_target_node(node)
  listeners[:on_global_variable_target_node_enter]&.each { |listener| listener.on_global_variable_target_node_enter(node) }
  super
  listeners[:on_global_variable_target_node_leave]&.each { |listener| listener.on_global_variable_target_node_leave(node) }
end

Отправить события входа и выхода для узлов GlobalVariableTargetNode и продолжить обход дерева.

Calls superclass method
visit_global_variable_write_node(node) Show source
# File lib/prism/dispatcher.rb, line 574
def visit_global_variable_write_node(node)
  listeners[:on_global_variable_write_node_enter]&.each { |listener| listener.on_global_variable_write_node_enter(node) }
  super
  listeners[:on_global_variable_write_node_leave]&.each { |listener| listener.on_global_variable_write_node_leave(node) }
end

Отправить события входа и выхода для узлов GlobalVariableWriteNode и продолжить обход дерева.

Calls superclass method
visit_hash_node(node) Show source
# File lib/prism/dispatcher.rb, line 582
def visit_hash_node(node)
  listeners[:on_hash_node_enter]&.each { |listener| listener.on_hash_node_enter(node) }
  super
  listeners[:on_hash_node_leave]&.each { |listener| listener.on_hash_node_leave(node) }
end

Отправить события входа и выхода для узлов HashNode и продолжить обход дерева.

Calls superclass method
visit_hash_pattern_node(node) Show source
# File lib/prism/dispatcher.rb, line 590
def visit_hash_pattern_node(node)
  listeners[:on_hash_pattern_node_enter]&.each { |listener| listener.on_hash_pattern_node_enter(node) }
  super
  listeners[:on_hash_pattern_node_leave]&.each { |listener| listener.on_hash_pattern_node_leave(node) }
end

Отправить события входа и выхода для узлов HashPatternNode и продолжить обход дерева.

Calls superclass method
visit_if_node(node) Show source
# File lib/prism/dispatcher.rb, line 598
def visit_if_node(node)
  listeners[:on_if_node_enter]&.each { |listener| listener.on_if_node_enter(node) }
  super
  listeners[:on_if_node_leave]&.each { |listener| listener.on_if_node_leave(node) }
end

Отправить события входа и выхода для узлов IfNode и продолжить обход дерева.

Calls superclass method
visit_imaginary_node(node) Show source
# File lib/prism/dispatcher.rb, line 606
def visit_imaginary_node(node)
  listeners[:on_imaginary_node_enter]&.each { |listener| listener.on_imaginary_node_enter(node) }
  super
  listeners[:on_imaginary_node_leave]&.each { |listener| listener.on_imaginary_node_leave(node) }
end

Отправить события входа и выхода для узлов ImaginaryNode и продолжить обход дерева.

Calls superclass method
visit_implicit_node(node) Show source
# File lib/prism/dispatcher.rb, line 614
def visit_implicit_node(node)
  listeners[:on_implicit_node_enter]&.each { |listener| listener.on_implicit_node_enter(node) }
  super
  listeners[:on_implicit_node_leave]&.each { |listener| listener.on_implicit_node_leave(node) }
end

Отправить события входа и выхода для узлов ImplicitNode и продолжить обход дерева.

Calls superclass method
visit_implicit_rest_node(node) Show source
# File lib/prism/dispatcher.rb, line 622
def visit_implicit_rest_node(node)
  listeners[:on_implicit_rest_node_enter]&.each { |listener| listener.on_implicit_rest_node_enter(node) }
  super
  listeners[:on_implicit_rest_node_leave]&.each { |listener| listener.on_implicit_rest_node_leave(node) }
end

Отправить события входа и выхода для узлов ImplicitRestNode и продолжить обход дерева.

Calls superclass method
visit_in_node(node) Show source
# File lib/prism/dispatcher.rb, line 630
def visit_in_node(node)
  listeners[:on_in_node_enter]&.each { |listener| listener.on_in_node_enter(node) }
  super
  listeners[:on_in_node_leave]&.each { |listener| listener.on_in_node_leave(node) }
end

Отправить события входа и выхода для узлов InNode и продолжить обход дерева.

Calls superclass method
visit_index_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 638
def visit_index_and_write_node(node)
  listeners[:on_index_and_write_node_enter]&.each { |listener| listener.on_index_and_write_node_enter(node) }
  super
  listeners[:on_index_and_write_node_leave]&.each { |listener| listener.on_index_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов IndexAndWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_index_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 646
def visit_index_operator_write_node(node)
  listeners[:on_index_operator_write_node_enter]&.each { |listener| listener.on_index_operator_write_node_enter(node) }
  super
  listeners[:on_index_operator_write_node_leave]&.each { |listener| listener.on_index_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов IndexOperatorWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_index_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 654
def visit_index_or_write_node(node)
  listeners[:on_index_or_write_node_enter]&.each { |listener| listener.on_index_or_write_node_enter(node) }
  super
  listeners[:on_index_or_write_node_leave]&.each { |listener| listener.on_index_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов IndexOrWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_index_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 662
def visit_index_target_node(node)
  listeners[:on_index_target_node_enter]&.each { |listener| listener.on_index_target_node_enter(node) }
  super
  listeners[:on_index_target_node_leave]&.each { |listener| listener.on_index_target_node_leave(node) }
end

Отправить события входа и выхода для узлов IndexTargetNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_instance_variable_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 670
def visit_instance_variable_and_write_node(node)
  listeners[:on_instance_variable_and_write_node_enter]&.each { |listener| listener.on_instance_variable_and_write_node_enter(node) }
  super
  listeners[:on_instance_variable_and_write_node_leave]&.each { |listener| listener.on_instance_variable_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов InstanceVariableAndWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_instance_variable_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 678
def visit_instance_variable_operator_write_node(node)
  listeners[:on_instance_variable_operator_write_node_enter]&.each { |listener| listener.on_instance_variable_operator_write_node_enter(node) }
  super
  listeners[:on_instance_variable_operator_write_node_leave]&.each { |listener| listener.on_instance_variable_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов InstanceVariableOperatorWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_instance_variable_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 686
def visit_instance_variable_or_write_node(node)
  listeners[:on_instance_variable_or_write_node_enter]&.each { |listener| listener.on_instance_variable_or_write_node_enter(node) }
  super
  listeners[:on_instance_variable_or_write_node_leave]&.each { |listener| listener.on_instance_variable_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов InstanceVariableOrWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_instance_variable_read_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 694
def visit_instance_variable_read_node(node)
  listeners[:on_instance_variable_read_node_enter]&.each { |listener| listener.on_instance_variable_read_node_enter(node) }
  super
  listeners[:on_instance_variable_read_node_leave]&.each { |listener| listener.on_instance_variable_read_node_leave(node) }
end

Отправить события входа и выхода для узлов InstanceVariableReadNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_instance_variable_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 702
def visit_instance_variable_target_node(node)
  listeners[:on_instance_variable_target_node_enter]&.each { |listener| listener.on_instance_variable_target_node_enter(node) }
  super
  listeners[:on_instance_variable_target_node_leave]&.each { |listener| listener.on_instance_variable_target_node_leave(node) }
end

Отправить события входа и выхода для узлов InstanceVariableTargetNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_instance_variable_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 710
def visit_instance_variable_write_node(node)
  listeners[:on_instance_variable_write_node_enter]&.each { |listener| listener.on_instance_variable_write_node_enter(node) }
  super
  listeners[:on_instance_variable_write_node_leave]&.each { |listener| listener.on_instance_variable_write_node_leave(node) }
end

Отправить события входа и выхода для узлов InstanceVariableWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_integer_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 718
def visit_integer_node(node)
  listeners[:on_integer_node_enter]&.each { |listener| listener.on_integer_node_enter(node) }
  super
  listeners[:on_integer_node_leave]&.each { |listener| listener.on_integer_node_leave(node) }
end

Отправить события входа и выхода для узлов IntegerNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_interpolated_match_last_line_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 726
def visit_interpolated_match_last_line_node(node)
  listeners[:on_interpolated_match_last_line_node_enter]&.each { |listener| listener.on_interpolated_match_last_line_node_enter(node) }
  super
  listeners[:on_interpolated_match_last_line_node_leave]&.each { |listener| listener.on_interpolated_match_last_line_node_leave(node) }
end

Отправить события входа и выхода для узлов InterpolatedMatchLastLineNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_interpolated_regular_expression_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 734
def visit_interpolated_regular_expression_node(node)
  listeners[:on_interpolated_regular_expression_node_enter]&.each { |listener| listener.on_interpolated_regular_expression_node_enter(node) }
  super
  listeners[:on_interpolated_regular_expression_node_leave]&.each { |listener| listener.on_interpolated_regular_expression_node_leave(node) }
end

Отправить события входа и выхода для узлов InterpolatedRegularExpressionNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_interpolated_string_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 742
def visit_interpolated_string_node(node)
  listeners[:on_interpolated_string_node_enter]&.each { |listener| listener.on_interpolated_string_node_enter(node) }
  super
  listeners[:on_interpolated_string_node_leave]&.each { |listener| listener.on_interpolated_string_node_leave(node) }
end

Отправить события входа и выхода для узлов InterpolatedStringNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_interpolated_symbol_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 750
def visit_interpolated_symbol_node(node)
  listeners[:on_interpolated_symbol_node_enter]&.each { |listener| listener.on_interpolated_symbol_node_enter(node) }
  super
  listeners[:on_interpolated_symbol_node_leave]&.each { |listener| listener.on_interpolated_symbol_node_leave(node) }
end

Отправить события входа и выхода для узлов InterpolatedSymbolNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_interpolated_x_string_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 758
def visit_interpolated_x_string_node(node)
  listeners[:on_interpolated_x_string_node_enter]&.each { |listener| listener.on_interpolated_x_string_node_enter(node) }
  super
  listeners[:on_interpolated_x_string_node_leave]&.each { |listener| listener.on_interpolated_x_string_node_leave(node) }
end

Отправить события входа и выхода для узлов InterpolatedXStringNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_keyword_hash_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 766
def visit_keyword_hash_node(node)
  listeners[:on_keyword_hash_node_enter]&.each { |listener| listener.on_keyword_hash_node_enter(node) }
  super
  listeners[:on_keyword_hash_node_leave]&.each { |listener| listener.on_keyword_hash_node_leave(node) }
end

Отправить события входа и выхода для узлов KeywordHashNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_keyword_rest_parameter_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 774
def visit_keyword_rest_parameter_node(node)
  listeners[:on_keyword_rest_parameter_node_enter]&.each { |listener| listener.on_keyword_rest_parameter_node_enter(node) }
  super
  listeners[:on_keyword_rest_parameter_node_leave]&.each { |listener| listener.on_keyword_rest_parameter_node_leave(node) }
end

Отправить события входа и выхода для узлов KeywordRestParameterNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_lambda_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 782
def visit_lambda_node(node)
  listeners[:on_lambda_node_enter]&.each { |listener| listener.on_lambda_node_enter(node) }
  super
  listeners[:on_lambda_node_leave]&.each { |listener| listener.on_lambda_node_leave(node) }
end

Отправить события входа и выхода для узлов LambdaNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_local_variable_and_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 790
def visit_local_variable_and_write_node(node)
  listeners[:on_local_variable_and_write_node_enter]&.each { |listener| listener.on_local_variable_and_write_node_enter(node) }
  super
  listeners[:on_local_variable_and_write_node_leave]&.each { |listener| listener.on_local_variable_and_write_node_leave(node) }
end

Отправить события входа и выхода для узлов LocalVariableAndWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_local_variable_operator_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 798
def visit_local_variable_operator_write_node(node)
  listeners[:on_local_variable_operator_write_node_enter]&.each { |listener| listener.on_local_variable_operator_write_node_enter(node) }
  super
  listeners[:on_local_variable_operator_write_node_leave]&.each { |listener| listener.on_local_variable_operator_write_node_leave(node) }
end

Отправить события входа и выхода для узлов LocalVariableOperatorWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_local_variable_or_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 806
def visit_local_variable_or_write_node(node)
  listeners[:on_local_variable_or_write_node_enter]&.each { |listener| listener.on_local_variable_or_write_node_enter(node) }
  super
  listeners[:on_local_variable_or_write_node_leave]&.each { |listener| listener.on_local_variable_or_write_node_leave(node) }
end

Отправить события входа и выхода для узлов LocalVariableOrWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_local_variable_read_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 814
def visit_local_variable_read_node(node)
  listeners[:on_local_variable_read_node_enter]&.each { |listener| listener.on_local_variable_read_node_enter(node) }
  super
  listeners[:on_local_variable_read_node_leave]&.each { |listener| listener.on_local_variable_read_node_leave(node) }
end

Отправить события входа и выхода для узлов LocalVariableReadNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_local_variable_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 822
def visit_local_variable_target_node(node)
  listeners[:on_local_variable_target_node_enter]&.each { |listener| listener.on_local_variable_target_node_enter(node) }
  super
  listeners[:on_local_variable_target_node_leave]&.each { |listener| listener.on_local_variable_target_node_leave(node) }
end

Отправить события входа и выхода для узлов LocalVariableTargetNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_local_variable_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 830
def visit_local_variable_write_node(node)
  listeners[:on_local_variable_write_node_enter]&.each { |listener| listener.on_local_variable_write_node_enter(node) }
  super
  listeners[:on_local_variable_write_node_leave]&.each { |listener| listener.on_local_variable_write_node_leave(node) }
end

Отправить события входа и выхода для узлов LocalVariableWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_match_last_line_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 838
def visit_match_last_line_node(node)
  listeners[:on_match_last_line_node_enter]&.each { |listener| listener.on_match_last_line_node_enter(node) }
  super
  listeners[:on_match_last_line_node_leave]&.each { |listener| listener.on_match_last_line_node_leave(node) }
end

Отправить события входа и выхода для узлов MatchLastLineNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_match_predicate_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 846
def visit_match_predicate_node(node)
  listeners[:on_match_predicate_node_enter]&.each { |listener| listener.on_match_predicate_node_enter(node) }
  super
  listeners[:on_match_predicate_node_leave]&.each { |listener| listener.on_match_predicate_node_leave(node) }
end

Отправить события входа и выхода для узлов MatchPredicateNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_match_required_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 854
def visit_match_required_node(node)
  listeners[:on_match_required_node_enter]&.each { |listener| listener.on_match_required_node_enter(node) }
  super
  listeners[:on_match_required_node_leave]&.each { |listener| listener.on_match_required_node_leave(node) }
end

Отправить события входа и выхода для узлов MatchRequiredNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_match_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 862
def visit_match_write_node(node)
  listeners[:on_match_write_node_enter]&.each { |listener| listener.on_match_write_node_enter(node) }
  super
  listeners[:on_match_write_node_leave]&.each { |listener| listener.on_match_write_node_leave(node) }
end

Отправить события входа и выхода для узлов MatchWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_missing_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 870
def visit_missing_node(node)
  listeners[:on_missing_node_enter]&.each { |listener| listener.on_missing_node_enter(node) }
  super
  listeners[:on_missing_node_leave]&.each { |listener| listener.on_missing_node_leave(node) }
end

Отправить события входа и выхода для узлов MissingNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_module_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 878
def visit_module_node(node)
  listeners[:on_module_node_enter]&.each { |listener| listener.on_module_node_enter(node) }
  super
  listeners[:on_module_node_leave]&.each { |listener| listener.on_module_node_leave(node) }
end

Отправить события входа и выхода для узлов ModuleNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_multi_target_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 886
def visit_multi_target_node(node)
  listeners[:on_multi_target_node_enter]&.each { |listener| listener.on_multi_target_node_enter(node) }
  super
  listeners[:on_multi_target_node_leave]&.each { |listener| listener.on_multi_target_node_leave(node) }
end

Отправить события входа и выхода для узлов MultiTargetNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_multi_write_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 894
def visit_multi_write_node(node)
  listeners[:on_multi_write_node_enter]&.each { |listener| listener.on_multi_write_node_enter(node) }
  super
  listeners[:on_multi_write_node_leave]&.each { |listener| listener.on_multi_write_node_leave(node) }
end

Отправить события входа и выхода для узлов MultiWriteNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_next_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 902
def visit_next_node(node)
  listeners[:on_next_node_enter]&.each { |listener| listener.on_next_node_enter(node) }
  super
  listeners[:on_next_node_leave]&.each { |listener| listener.on_next_node_leave(node) }
end

Отправить события входа и выхода для узлов NextNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_nil_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 910
def visit_nil_node(node)
  listeners[:on_nil_node_enter]&.each { |listener| listener.on_nil_node_enter(node) }
  super
  listeners[:on_nil_node_leave]&.each { |listener| listener.on_nil_node_leave(node) }
end

Отправить события входа и выхода для узлов NilNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_no_keywords_parameter_node(node) Show source
# File lib/prism/dispatcher.rb, line 918
def visit_no_keywords_parameter_node(node)
  listeners[:on_no_keywords_parameter_node_enter]&.each { |listener| listener.on_no_keywords_parameter_node_enter(node) }
  super
  listeners[:on_no_keywords_parameter_node_leave]&.each { |listener| listener.on_no_keywords_parameter_node_leave(node) }
end

Отправка событий входа и выхода для узлов NoKeywordsParameterNode и продолжение обхода дерева.

Calls superclass method
visit_numbered_parameters_node(node) Show source
# File lib/prism/dispatcher.rb, line 926
def visit_numbered_parameters_node(node)
  listeners[:on_numbered_parameters_node_enter]&.each { |listener| listener.on_numbered_parameters_node_enter(node) }
  super
  listeners[:on_numbered_parameters_node_leave]&.each { |listener| listener.on_numbered_parameters_node_leave(node) }
end

Отправка событий входа и выхода для узлов NumberedParametersNode и продолжение обхода дерева.

Calls superclass method
visit_numbered_reference_read_node(node) Show source
# File lib/prism/dispatcher.rb, line 934
def visit_numbered_reference_read_node(node)
  listeners[:on_numbered_reference_read_node_enter]&.each { |listener| listener.on_numbered_reference_read_node_enter(node) }
  super
  listeners[:on_numbered_reference_read_node_leave]&.each { |listener| listener.on_numbered_reference_read_node_leave(node) }
end

Отправка событий входа и выхода для узлов NumberedReferenceReadNode и продолжение обхода дерева.

Calls superclass method
visit_optional_keyword_parameter_node(node) Show source
# File lib/prism/dispatcher.rb, line 942
def visit_optional_keyword_parameter_node(node)
  listeners[:on_optional_keyword_parameter_node_enter]&.each { |listener| listener.on_optional_keyword_parameter_node_enter(node) }
  super
  listeners[:on_optional_keyword_parameter_node_leave]&.each { |listener| listener.on_optional_keyword_parameter_node_leave(node) }
end

Отправка событий входа и выхода для узлов OptionalKeywordParameterNode и продолжение обхода дерева.

Calls superclass method
visit_optional_parameter_node(node) Show source
# File lib/prism/dispatcher.rb, line 950
def visit_optional_parameter_node(node)
  listeners[:on_optional_parameter_node_enter]&.each { |listener| listener.on_optional_parameter_node_enter(node) }
  super
  listeners[:on_optional_parameter_node_leave]&.each { |listener| listener.on_optional_parameter_node_leave(node) }
end

Отправка событий входа и выхода для узлов OptionalParameterNode и продолжение обхода дерева.

Calls superclass method
visit_or_node(node) Show source
# File lib/prism/dispatcher.rb, line 958
def visit_or_node(node)
  listeners[:on_or_node_enter]&.each { |listener| listener.on_or_node_enter(node) }
  super
  listeners[:on_or_node_leave]&.each { |listener| listener.on_or_node_leave(node) }
end

Отправка событий входа и выхода для узлов OrNode и продолжение обхода дерева.

Calls superclass method
visit_parameters_node(node) Show source
# File lib/prism/dispatcher.rb, line 966
def visit_parameters_node(node)
  listeners[:on_parameters_node_enter]&.each { |listener| listener.on_parameters_node_enter(node) }
  super
  listeners[:on_parameters_node_leave]&.each { |listener| listener.on_parameters_node_leave(node) }
end

Отправка событий входа и выхода для узлов ParametersNode и продолжение обхода дерева.

Calls superclass method
visit_parentheses_node(node) Show source
# File lib/prism/dispatcher.rb, line 974
def visit_parentheses_node(node)
  listeners[:on_parentheses_node_enter]&.each { |listener| listener.on_parentheses_node_enter(node) }
  super
  listeners[:on_parentheses_node_leave]&.each { |listener| listener.on_parentheses_node_leave(node) }
end

Отправка событий входа и выхода для узлов ParenthesesNode и продолжение обхода дерева.

Calls superclass method
visit_pinned_expression_node(node) Show source
# File lib/prism/dispatcher.rb, line 982
def visit_pinned_expression_node(node)
  listeners[:on_pinned_expression_node_enter]&.each { |listener| listener.on_pinned_expression_node_enter(node) }
  super
  listeners[:on_pinned_expression_node_leave]&.each { |listener| listener.on_pinned_expression_node_leave(node) }
end

Отправка событий входа и выхода для узлов PinnedExpressionNode и продолжение обхода дерева.

Calls superclass method
visit_pinned_variable_node(node) Show source
# File lib/prism/dispatcher.rb, line 990
def visit_pinned_variable_node(node)
  listeners[:on_pinned_variable_node_enter]&.each { |listener| listener.on_pinned_variable_node_enter(node) }
  super
  listeners[:on_pinned_variable_node_leave]&.each { |listener| listener.on_pinned_variable_node_leave(node) }
end

Отправка событий входа и выхода для узлов PinnedVariableNode и продолжение обхода дерева.

Calls superclass method
visit_post_execution_node(node) Show source
# File lib/prism/dispatcher.rb, line 998
def visit_post_execution_node(node)
  listeners[:on_post_execution_node_enter]&.each { |listener| listener.on_post_execution_node_enter(node) }
  super
  listeners[:on_post_execution_node_leave]&.each { |listener| listener.on_post_execution_node_leave(node) }
end

Отправка событий входа и выхода для узлов PostExecutionNode и продолжение обхода дерева.

Calls superclass method
visit_pre_execution_node(node) Show source
# File lib/prism/dispatcher.rb, line 1006
def visit_pre_execution_node(node)
  listeners[:on_pre_execution_node_enter]&.each { |listener| listener.on_pre_execution_node_enter(node) }
  super
  listeners[:on_pre_execution_node_leave]&.each { |listener| listener.on_pre_execution_node_leave(node) }
end

Отправка событий входа и выхода для узлов PreExecutionNode и продолжение обхода дерева.

Calls superclass method
visit_program_node(node) Show source
# File lib/prism/dispatcher.rb, line 1014
def visit_program_node(node)
  listeners[:on_program_node_enter]&.each { |listener| listener.on_program_node_enter(node) }
  super
  listeners[:on_program_node_leave]&.each { |listener| listener.on_program_node_leave(node) }
end

Отправка событий входа и выхода для узлов ProgramNode и продолжение обхода дерева.

Calls superclass method
visit_range_node(node) Show source
# File lib/prism/dispatcher.rb, line 1022
def visit_range_node(node)
  listeners[:on_range_node_enter]&.each { |listener| listener.on_range_node_enter(node) }
  super
  listeners[:on_range_node_leave]&.each { |listener| listener.on_range_node_leave(node) }
end

Отправка событий входа и выхода для узлов RangeNode и продолжение обхода дерева.

Calls superclass method
visit_rational_node(node) Show source
# File lib/prism/dispatcher.rb, line 1030
def visit_rational_node(node)
  listeners[:on_rational_node_enter]&.each { |listener| listener.on_rational_node_enter(node) }
  super
  listeners[:on_rational_node_leave]&.each { |listener| listener.on_rational_node_leave(node) }
end

Отправка событий входа и выхода для узлов RationalNode и продолжение обхода дерева.

Calls superclass method
visit_redo_node(node) Show source
# File lib/prism/dispatcher.rb, line 1038
def visit_redo_node(node)
  listeners[:on_redo_node_enter]&.each { |listener| listener.on_redo_node_enter(node) }
  super
  listeners[:on_redo_node_leave]&.each { |listener| listener.on_redo_node_leave(node) }
end

Отправка событий входа и выхода для узлов RedoNode и продолжение обхода дерева.

Calls superclass method
visit_regular_expression_node(node) Show source
# File lib/prism/dispatcher.rb, line 1046
def visit_regular_expression_node(node)
  listeners[:on_regular_expression_node_enter]&.each { |listener| listener.on_regular_expression_node_enter(node) }
  super
  listeners[:on_regular_expression_node_leave]&.each { |listener| listener.on_regular_expression_node_leave(node) }
end

Отправка событий входа и выхода для узлов RegularExpressionNode и продолжение обхода дерева.

Calls superclass method
visit_required_keyword_parameter_node(node) Show source
# File lib/prism/dispatcher.rb, line 1054
def visit_required_keyword_parameter_node(node)
  listeners[:on_required_keyword_parameter_node_enter]&.each { |listener| listener.on_required_keyword_parameter_node_enter(node) }
  super
  listeners[:on_required_keyword_parameter_node_leave]&.each { |listener| listener.on_required_keyword_parameter_node_leave(node) }
end

Отправка событий входа и выхода для узлов RequiredKeywordParameterNode и продолжение обхода дерева.

Calls superclass method
visit_required_parameter_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1062
def visit_required_parameter_node(node)
  listeners[:on_required_parameter_node_enter]&.each { |listener| listener.on_required_parameter_node_enter(node) }
  super
  listeners[:on_required_parameter_node_leave]&.each { |listener| listener.on_required_parameter_node_leave(node) }
end

Отправить события входа и выхода для узлов RequiredParameterNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_rescue_modifier_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1070
def visit_rescue_modifier_node(node)
  listeners[:on_rescue_modifier_node_enter]&.each { |listener| listener.on_rescue_modifier_node_enter(node) }
  super
  listeners[:on_rescue_modifier_node_leave]&.each { |listener| listener.on_rescue_modifier_node_leave(node) }
end

Отправить события входа и выхода для узлов RescueModifierNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_rescue_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1078
def visit_rescue_node(node)
  listeners[:on_rescue_node_enter]&.each { |listener| listener.on_rescue_node_enter(node) }
  super
  listeners[:on_rescue_node_leave]&.each { |listener| listener.on_rescue_node_leave(node) }
end

Отправить события входа и выхода для узлов RescueNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_rest_parameter_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1086
def visit_rest_parameter_node(node)
  listeners[:on_rest_parameter_node_enter]&.each { |listener| listener.on_rest_parameter_node_enter(node) }
  super
  listeners[:on_rest_parameter_node_leave]&.each { |listener| listener.on_rest_parameter_node_leave(node) }
end

Отправить события входа и выхода для узлов RestParameterNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_retry_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1094
def visit_retry_node(node)
  listeners[:on_retry_node_enter]&.each { |listener| listener.on_retry_node_enter(node) }
  super
  listeners[:on_retry_node_leave]&.each { |listener| listener.on_retry_node_leave(node) }
end

Отправить события входа и выхода для узлов RetryNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_return_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1102
def visit_return_node(node)
  listeners[:on_return_node_enter]&.each { |listener| listener.on_return_node_enter(node) }
  super
  listeners[:on_return_node_leave]&.each { |listener| listener.on_return_node_leave(node) }
end

Отправить события входа и выхода для узлов ReturnNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_self_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1110
def visit_self_node(node)
  listeners[:on_self_node_enter]&.each { |listener| listener.on_self_node_enter(node) }
  super
  listeners[:on_self_node_leave]&.each { |listener| listener.on_self_node_leave(node) }
end

Отправить события входа и выхода для узлов SelfNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_singleton_class_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1118
def visit_singleton_class_node(node)
  listeners[:on_singleton_class_node_enter]&.each { |listener| listener.on_singleton_class_node_enter(node) }
  super
  listeners[:on_singleton_class_node_leave]&.each { |listener| listener.on_singleton_class_node_leave(node) }
end

Отправить события входа и выхода для узлов SingletonClassNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_source_encoding_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1126
def visit_source_encoding_node(node)
  listeners[:on_source_encoding_node_enter]&.each { |listener| listener.on_source_encoding_node_enter(node) }
  super
  listeners[:on_source_encoding_node_leave]&.each { |listener| listener.on_source_encoding_node_leave(node) }
end

Отправить события входа и выхода для узлов SourceEncodingNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_source_file_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1134
def visit_source_file_node(node)
  listeners[:on_source_file_node_enter]&.each { |listener| listener.on_source_file_node_enter(node) }
  super
  listeners[:on_source_file_node_leave]&.each { |listener| listener.on_source_file_node_leave(node) }
end

Отправить события входа и выхода для узлов SourceFileNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_source_line_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1142
def visit_source_line_node(node)
  listeners[:on_source_line_node_enter]&.each { |listener| listener.on_source_line_node_enter(node) }
  super
  listeners[:on_source_line_node_leave]&.each { |listener| listener.on_source_line_node_leave(node) }
end

Отправить события входа и выхода для узлов SourceLineNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_splat_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1150
def visit_splat_node(node)
  listeners[:on_splat_node_enter]&.each { |listener| listener.on_splat_node_enter(node) }
  super
  listeners[:on_splat_node_leave]&.each { |listener| listener.on_splat_node_leave(node) }
end

Отправить события входа и выхода для узлов SplatNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_statements_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1158
def visit_statements_node(node)
  listeners[:on_statements_node_enter]&.each { |listener| listener.on_statements_node_enter(node) }
  super
  listeners[:on_statements_node_leave]&.each { |listener| listener.on_statements_node_leave(node) }
end

Отправить события входа и выхода для узлов StatementsNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_string_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1166
def visit_string_node(node)
  listeners[:on_string_node_enter]&.each { |listener| listener.on_string_node_enter(node) }
  super
  listeners[:on_string_node_leave]&.each { |listener| listener.on_string_node_leave(node) }
end

Отправить события входа и выхода для узлов StringNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_super_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1174
def visit_super_node(node)
  listeners[:on_super_node_enter]&.each { |listener| listener.on_super_node_enter(node) }
  super
  listeners[:on_super_node_leave]&.each { |listener| listener.on_super_node_leave(node) }
end

Отправить события входа и выхода для узлов SuperNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_symbol_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1182
def visit_symbol_node(node)
  listeners[:on_symbol_node_enter]&.each { |listener| listener.on_symbol_node_enter(node) }
  super
  listeners[:on_symbol_node_leave]&.each { |listener| listener.on_symbol_node_leave(node) }
end

Отправить события входа и выхода для узлов SymbolNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_true_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1190
def visit_true_node(node)
  listeners[:on_true_node_enter]&.each { |listener| listener.on_true_node_enter(node) }
  super
  listeners[:on_true_node_leave]&.each { |listener| listener.on_true_node_leave(node) }
end

Отправить события входа и выхода для узлов TrueNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_undef_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1198
def visit_undef_node(node)
  listeners[:on_undef_node_enter]&.each { |listener| listener.on_undef_node_enter(node) }
  super
  listeners[:on_undef_node_leave]&.each { |listener| listener.on_undef_node_leave(node) }
end

Отправить события входа и выхода для узлов UndefNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_unless_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1206
def visit_unless_node(node)
  listeners[:on_unless_node_enter]&.each { |listener| listener.on_unless_node_enter(node) }
  super
  listeners[:on_unless_node_leave]&.each { |listener| listener.on_unless_node_leave(node) }
end

Отправить события входа и выхода для узлов UnlessNode и продолжить обход дерева.

Вызывает метод суперкласса
visit_until_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1214
def visit_until_node(node)
  listeners[:on_until_node_enter]&.each { |listener| listener.on_until_node_enter(node) }
  super
  listeners[:on_until_node_leave]&.each { |listener| listener.on_until_node_leave(node) }
end

Отправляет события входа и выхода для узлов UntilNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_when_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1222
def visit_when_node(node)
  listeners[:on_when_node_enter]&.each { |listener| listener.on_when_node_enter(node) }
  super
  listeners[:on_when_node_leave]&.each { |listener| listener.on_when_node_leave(node) }
end

Отправляет события входа и выхода для узлов WhenNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_while_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1230
def visit_while_node(node)
  listeners[:on_while_node_enter]&.each { |listener| listener.on_while_node_enter(node) }
  super
  listeners[:on_while_node_leave]&.each { |listener| listener.on_while_node_leave(node) }
end

Отправляет события входа и выхода для узлов WhileNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_x_string_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1238
def visit_x_string_node(node)
  listeners[:on_x_string_node_enter]&.each { |listener| listener.on_x_string_node_enter(node) }
  super
  listeners[:on_x_string_node_leave]&.each { |listener| listener.on_x_string_node_leave(node) }
end

Отправляет события входа и выхода для узлов XStringNode и продолжает обход дерева.

Вызывает метод суперкласса
visit_yield_node(node) Показать исходный код
# File lib/prism/dispatcher.rb, line 1246
def visit_yield_node(node)
  listeners[:on_yield_node_enter]&.each { |listener| listener.on_yield_node_enter(node) }
  super
  listeners[:on_yield_node_leave]&.each { |listener| listener.on_yield_node_leave(node) }
end

Отправляет события входа и выхода для узлов YieldNode и продолжает обход дерева.

Вызывает метод суперкласса

Ruby Core © 1993–2022 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API