ruby-lsp 0.11.1 → 0.12.0

data/lib/ruby_lsp/requests/support/semantic_token_encoder.rb

@@ -43,15 +43,18 @@ module RubyLsp
         def compute_delta(token)
           row = token.location.start_line - 1
           column = token.location.start_column
-          delta_line = row - @current_row
 
-          delta_column = column
-          delta_column -= @current_column if delta_line == 0
+          begin
+            delta_line = row - @current_row
 
-          [delta_line, delta_column, token.length, token.type, encode_modifiers(token.modifier)]
-        ensure
-          @current_row = row
-          @current_column = column
+            delta_column = column
+            delta_column -= @current_column if delta_line == 0
+
+            [delta_line, delta_column, token.length, token.type, encode_modifiers(token.modifier)]
+          ensure
+            @current_row = row
+            @current_column = column
+          end
         end
 
         # Encode an array of modifiers to positions onto a bit flag

data/lib/ruby_lsp/requests/support/sorbet.rb

@@ -10,39 +10,39 @@ module RubyLsp
 
           ANNOTATIONS = T.let(
             {
-              "abstract!" => Annotation.new(arity: 0),
-              "absurd" => Annotation.new(arity: 1, receiver: true),
-              "all" => Annotation.new(arity: (2..), receiver: true),
-              "any" => Annotation.new(arity: (2..), receiver: true),
-              "assert_type!" => Annotation.new(arity: 2, receiver: true),
-              "attached_class" => Annotation.new(arity: 0, receiver: true),
-              "bind" => Annotation.new(arity: 2, receiver: true),
-              "cast" => Annotation.new(arity: 2, receiver: true),
-              "class_of" => Annotation.new(arity: 1, receiver: true),
-              "enums" => Annotation.new(arity: 0),
-              "interface!" => Annotation.new(arity: 0),
-              "let" => Annotation.new(arity: 2, receiver: true),
-              "mixes_in_class_methods" => Annotation.new(arity: 1),
-              "must" => Annotation.new(arity: 1, receiver: true),
-              "must_because" => Annotation.new(arity: 1, receiver: true),
-              "nilable" => Annotation.new(arity: 1, receiver: true),
-              "noreturn" => Annotation.new(arity: 0, receiver: true),
-              "requires_ancestor" => Annotation.new(arity: 0),
-              "reveal_type" => Annotation.new(arity: 1, receiver: true),
-              "sealed!" => Annotation.new(arity: 0),
-              "self_type" => Annotation.new(arity: 0, receiver: true),
-              "sig" => Annotation.new(arity: 0),
-              "type_member" => Annotation.new(arity: (0..1)),
-              "type_template" => Annotation.new(arity: 0),
-              "unsafe" => Annotation.new(arity: 1),
-              "untyped" => Annotation.new(arity: 0, receiver: true),
+              abstract!: Annotation.new(arity: 0),
+              absurd: Annotation.new(arity: 1, receiver: true),
+              all: Annotation.new(arity: (2..), receiver: true),
+              any: Annotation.new(arity: (2..), receiver: true),
+              assert_type!: Annotation.new(arity: 2, receiver: true),
+              attached_class: Annotation.new(arity: 0, receiver: true),
+              bind: Annotation.new(arity: 2, receiver: true),
+              cast: Annotation.new(arity: 2, receiver: true),
+              class_of: Annotation.new(arity: 1, receiver: true),
+              enums: Annotation.new(arity: 0),
+              interface!: Annotation.new(arity: 0),
+              let: Annotation.new(arity: 2, receiver: true),
+              mixes_in_class_methods: Annotation.new(arity: 1),
+              must: Annotation.new(arity: 1, receiver: true),
+              must_because: Annotation.new(arity: 1, receiver: true),
+              nilable: Annotation.new(arity: 1, receiver: true),
+              noreturn: Annotation.new(arity: 0, receiver: true),
+              requires_ancestor: Annotation.new(arity: 0),
+              reveal_type: Annotation.new(arity: 1, receiver: true),
+              sealed!: Annotation.new(arity: 0),
+              self_type: Annotation.new(arity: 0, receiver: true),
+              sig: Annotation.new(arity: 0),
+              type_member: Annotation.new(arity: (0..1)),
+              type_template: Annotation.new(arity: 0),
+              unsafe: Annotation.new(arity: 1),
+              untyped: Annotation.new(arity: 0, receiver: true),
             },
-            T::Hash[String, Annotation],
+            T::Hash[Symbol, Annotation],
           )
 
           sig do
             params(
-              node: YARP::CallNode,
+              node: Prism::CallNode,
             ).returns(T::Boolean)
           end
           def annotation?(node)

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -73,14 +73,14 @@ module RubyLsp
 
       private
 
-      sig { params(entry: RubyIndexer::Index::Entry).returns(T.nilable(Integer)) }
+      sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
       def kind_for_entry(entry)
         case entry
-        when RubyIndexer::Index::Entry::Class
+        when RubyIndexer::Entry::Class
           Constant::SymbolKind::CLASS
-        when RubyIndexer::Index::Entry::Module
+        when RubyIndexer::Entry::Module
           Constant::SymbolKind::NAMESPACE
-        when RubyIndexer::Index::Entry::Constant
+        when RubyIndexer::Entry::Constant
           Constant::SymbolKind::CONSTANT
         end
       end

data/lib/ruby_lsp/requests.rb

@@ -51,7 +51,6 @@ module RubyLsp
       autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
       autoload :Annotation, "ruby_lsp/requests/support/annotation"
       autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
-      autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
       autoload :Common, "ruby_lsp/requests/support/common"
       autoload :FormatterRunner, "ruby_lsp/requests/support/formatter_runner"

data/lib/ruby_lsp/setup_bundler.rb

@@ -46,9 +46,9 @@ module RubyLsp
       @dependencies = T.let(load_dependencies, T::Hash[String, T.untyped])
     end
 
-    # Setups up the custom bundle and returns the `BUNDLE_GEMFILE` and `BUNDLE_PATH` that should be used for running the
-    # server
-    sig { returns([String, T.nilable(String)]) }
+    # Sets up the custom bundle and returns the `BUNDLE_GEMFILE`, `BUNDLE_PATH` and `BUNDLE_APP_CONFIG` that should be
+    # used for running the server
+    sig { returns([String, T.nilable(String), T.nilable(String)]) }
     def setup!
       raise BundleNotLocked if @gemfile&.exist? && !@lockfile&.exist?
 
@@ -156,7 +156,7 @@ module RubyLsp
       dependencies
     end
 
-    sig { params(bundle_gemfile: T.nilable(Pathname)).returns([String, T.nilable(String)]) }
+    sig { params(bundle_gemfile: T.nilable(Pathname)).returns([String, T.nilable(String), T.nilable(String)]) }
     def run_bundle_install(bundle_gemfile = @gemfile)
       # If the user has a custom bundle path configured, we need to ensure that we will use the absolute and not
       # relative version of it when running `bundle install`. This is necessary to avoid installing the gems under the
@@ -170,6 +170,9 @@ module RubyLsp
       env["BUNDLE_GEMFILE"] = bundle_gemfile.to_s
       env["BUNDLE_PATH"] = expanded_path if expanded_path
 
+      local_config_path = File.join(Dir.pwd, ".bundle")
+      env["BUNDLE_APP_CONFIG"] = local_config_path if Dir.exist?(local_config_path)
+
       # If both `ruby-lsp` and `debug` are already in the Gemfile, then we shouldn't try to upgrade them or else we'll
       # produce undesired source control changes. If the custom bundle was just created and either `ruby-lsp` or `debug`
       # weren't a part of the Gemfile, then we need to run `bundle install` for the first time to generate the
@@ -200,7 +203,7 @@ module RubyLsp
       # Add bundle update
       warn("Ruby LSP> Running bundle install for the custom bundle. This may take a while...")
       system(env, command)
-      [bundle_gemfile.to_s, expanded_path]
+      [bundle_gemfile.to_s, expanded_path, env["BUNDLE_APP_CONFIG"]]
     end
 
     sig { returns(T::Boolean) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.12.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-04 00:00:00.000000000 Z
+date: 2023-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -25,45 +25,46 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 3.17.0
 - !ruby/object:Gem::Dependency
-  name: sorbet-runtime
+  name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.5685
+        version: 0.15.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.16'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.5685
+        version: 0.15.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 - !ruby/object:Gem::Dependency
-  name: yarp
+  name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.12'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.13'
+        version: 0.5.5685
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.12'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '0.13'
+        version: 0.5.5685
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
 executables:
 - ruby-lsp
 - ruby-lsp-check
+- ruby-lsp-doctor
 extensions: []
 extra_rdoc_files: []
 files:
@@ -72,10 +73,12 @@ files:
 - VERSION
 - exe/ruby-lsp
 - exe/ruby-lsp-check
+- exe/ruby-lsp-doctor
 - lib/core_ext/uri.rb
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/ruby-lsp.rb
 - lib/ruby_indexer/lib/ruby_indexer/configuration.rb
+- lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
 - lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
@@ -85,12 +88,12 @@ files:
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
 - lib/ruby_indexer/test/index_test.rb
+- lib/ruby_indexer/test/method_test.rb
 - lib/ruby_indexer/test/prefix_tree_test.rb
 - lib/ruby_indexer/test/test_case.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/check_docs.rb
 - lib/ruby_lsp/document.rb
-- lib/ruby_lsp/event_emitter.rb
 - lib/ruby_lsp/executor.rb
 - lib/ruby_lsp/internal.rb
 - lib/ruby_lsp/listener.rb
@@ -118,7 +121,6 @@ files:
 - lib/ruby_lsp/requests/support/common.rb
 - lib/ruby_lsp/requests/support/dependency_detector.rb
 - lib/ruby_lsp/requests/support/formatter_runner.rb
-- lib/ruby_lsp/requests/support/highlight_target.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostic.rb
 - lib/ruby_lsp/requests/support/rubocop_diagnostics_runner.rb
 - lib/ruby_lsp/requests/support/rubocop_formatting_runner.rb
@@ -153,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.20
+rubygems_version: 3.4.21
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby

data/lib/ruby_lsp/event_emitter.rb

@@ -1,351 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # EventEmitter is an intermediary between our requests and YARP visitors. It's used to visit the document's AST
-  # and emit events that the requests can listen to for providing functionality. Usages:
-  #
-  # - For positional requests, locate the target node and use `emit_for_target` to fire events for each listener
-  # - For nonpositional requests, use `visit` to go through the AST, which will fire events for each listener as nodes
-  # are found
-  #
-  # # Example
-  #
-  # ```ruby
-  # target_node = document.locate_node(position)
-  # emitter = EventEmitter.new
-  # listener = Requests::Hover.new(emitter, @message_queue)
-  # emitter.emit_for_target(target_node)
-  # listener.response
-  # ```
-  class EventEmitter < YARP::Visitor
-    extend T::Sig
-
-    sig { void }
-    def initialize
-      @listeners = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[Symbol, T::Array[Listener[T.untyped]]])
-      super()
-    end
-
-    sig { params(listener: Listener[T.untyped], events: Symbol).void }
-    def register(listener, *events)
-      events.each { |event| T.must(@listeners[event]) << listener }
-    end
-
-    # Emit events for a specific node. This is similar to the regular `visit` method, but avoids going deeper into the
-    # tree for performance
-    sig { params(node: T.nilable(YARP::Node)).void }
-    def emit_for_target(node)
-      case node
-      when YARP::CallNode
-        @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
-      when YARP::ConstantPathNode
-        @listeners[:on_constant_path]&.each { |l| T.unsafe(l).on_constant_path(node) }
-      when YARP::StringNode
-        @listeners[:on_string]&.each { |l| T.unsafe(l).on_string(node) }
-      when YARP::ClassNode
-        @listeners[:on_class]&.each { |l| T.unsafe(l).on_class(node) }
-      when YARP::ModuleNode
-        @listeners[:on_module]&.each { |l| T.unsafe(l).on_module(node) }
-      when YARP::ConstantWriteNode
-        @listeners[:on_constant_write]&.each { |l| T.unsafe(l).on_constant_write(node) }
-      when YARP::ConstantReadNode
-        @listeners[:on_constant_read]&.each { |l| T.unsafe(l).on_constant_read(node) }
-      end
-    end
-
-    # Visit dispatchers are below. Notice that for nodes that create a new scope (e.g.: classes, modules, method defs)
-    # we need both an `on_*` and `after_*` event. This is because some requests must know when we exit the scope
-    sig { override.params(node: T.nilable(YARP::Node)).void }
-    def visit(node)
-      @listeners[:on_node]&.each { |l| T.unsafe(l).on_node(node) }
-      super
-    end
-
-    sig { params(nodes: T::Array[T.nilable(YARP::Node)]).void }
-    def visit_all(nodes)
-      nodes.each { |node| visit(node) }
-    end
-
-    sig { override.params(node: YARP::ClassNode).void }
-    def visit_class_node(node)
-      @listeners[:on_class]&.each { |l| T.unsafe(l).on_class(node) }
-      super
-      @listeners[:after_class]&.each { |l| T.unsafe(l).after_class(node) }
-    end
-
-    sig { override.params(node: YARP::ModuleNode).void }
-    def visit_module_node(node)
-      @listeners[:on_module]&.each { |l| T.unsafe(l).on_module(node) }
-      super
-      @listeners[:after_module]&.each { |l| T.unsafe(l).after_module(node) }
-    end
-
-    sig { override.params(node: YARP::CallNode).void }
-    def visit_call_node(node)
-      @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
-      super
-      @listeners[:after_call]&.each { |l| T.unsafe(l).after_call(node) }
-    end
-
-    sig { override.params(node: YARP::InstanceVariableWriteNode).void }
-    def visit_instance_variable_write_node(node)
-      @listeners[:on_instance_variable_write]&.each { |l| T.unsafe(l).on_instance_variable_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ClassVariableWriteNode).void }
-    def visit_class_variable_write_node(node)
-      @listeners[:on_class_variable_write]&.each { |l| T.unsafe(l).on_class_variable_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::DefNode).void }
-    def visit_def_node(node)
-      @listeners[:on_def]&.each { |l| T.unsafe(l).on_def(node) }
-      super
-      @listeners[:after_def]&.each { |l| T.unsafe(l).after_def(node) }
-    end
-
-    sig { override.params(node: YARP::BlockNode).void }
-    def visit_block_node(node)
-      @listeners[:on_block]&.each { |l| T.unsafe(l).on_block(node) }
-      super
-      @listeners[:after_block]&.each { |l| T.unsafe(l).after_block(node) }
-    end
-
-    sig { override.params(node: YARP::SelfNode).void }
-    def visit_self_node(node)
-      @listeners[:on_self]&.each { |l| T.unsafe(l).on_self(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::RescueNode).void }
-    def visit_rescue_node(node)
-      @listeners[:on_rescue]&.each { |l| T.unsafe(l).on_rescue(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::BlockParameterNode).void }
-    def visit_block_parameter_node(node)
-      @listeners[:on_block_parameter]&.each { |l| T.unsafe(l).on_block_parameter(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::KeywordParameterNode).void }
-    def visit_keyword_parameter_node(node)
-      @listeners[:on_keyword_parameter]&.each { |l| T.unsafe(l).on_keyword_parameter(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::KeywordRestParameterNode).void }
-    def visit_keyword_rest_parameter_node(node)
-      @listeners[:on_keyword_rest_parameter]&.each { |l| T.unsafe(l).on_keyword_rest_parameter(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::OptionalParameterNode).void }
-    def visit_optional_parameter_node(node)
-      @listeners[:on_optional_parameter]&.each { |l| T.unsafe(l).on_optional_parameter(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::RequiredParameterNode).void }
-    def visit_required_parameter_node(node)
-      @listeners[:on_required_parameter]&.each { |l| T.unsafe(l).on_required_parameter(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::RestParameterNode).void }
-    def visit_rest_parameter_node(node)
-      @listeners[:on_rest_parameter]&.each { |l| T.unsafe(l).on_rest_parameter(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantReadNode).void }
-    def visit_constant_read_node(node)
-      @listeners[:on_constant_read]&.each { |l| T.unsafe(l).on_constant_read(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantPathNode).void }
-    def visit_constant_path_node(node)
-      @listeners[:on_constant_path]&.each { |l| T.unsafe(l).on_constant_path(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantPathWriteNode).void }
-    def visit_constant_path_write_node(node)
-      @listeners[:on_constant_path_write]&.each { |l| T.unsafe(l).on_constant_path_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantWriteNode).void }
-    def visit_constant_write_node(node)
-      @listeners[:on_constant_write]&.each { |l| T.unsafe(l).on_constant_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantAndWriteNode).void }
-    def visit_constant_and_write_node(node)
-      @listeners[:on_constant_and_write]&.each { |l| T.unsafe(l).on_constant_and_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantOperatorWriteNode).void }
-    def visit_constant_operator_write_node(node)
-      @listeners[:on_constant_operator_write]&.each { |l| T.unsafe(l).on_constant_operator_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantOrWriteNode).void }
-    def visit_constant_or_write_node(node)
-      @listeners[:on_constant_or_write]&.each { |l| T.unsafe(l).on_constant_or_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantTargetNode).void }
-    def visit_constant_target_node(node)
-      @listeners[:on_constant_target]&.each { |l| T.unsafe(l).on_constant_target(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::LocalVariableWriteNode).void }
-    def visit_local_variable_write_node(node)
-      @listeners[:on_local_variable_write]&.each { |l| T.unsafe(l).on_local_variable_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::LocalVariableReadNode).void }
-    def visit_local_variable_read_node(node)
-      @listeners[:on_local_variable_read]&.each { |l| T.unsafe(l).on_local_variable_read(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::LocalVariableAndWriteNode).void }
-    def visit_local_variable_and_write_node(node)
-      @listeners[:on_local_variable_and_write]&.each { |l| T.unsafe(l).on_local_variable_and_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::LocalVariableOperatorWriteNode).void }
-    def visit_local_variable_operator_write_node(node)
-      @listeners[:on_local_variable_operator_write]&.each { |l| T.unsafe(l).on_local_variable_operator_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::LocalVariableOrWriteNode).void }
-    def visit_local_variable_or_write_node(node)
-      @listeners[:on_local_variable_or_write]&.each { |l| T.unsafe(l).on_local_variable_or_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::LocalVariableTargetNode).void }
-    def visit_local_variable_target_node(node)
-      @listeners[:on_local_variable_target]&.each { |l| T.unsafe(l).on_local_variable_target(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::BlockLocalVariableNode).void }
-    def visit_block_local_variable_node(node)
-      @listeners[:on_block_local_variable]&.each { |l| T.unsafe(l).on_block_local_variable(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::IfNode).void }
-    def visit_if_node(node)
-      @listeners[:on_if]&.each { |l| T.unsafe(l).on_if(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::InNode).void }
-    def visit_in_node(node)
-      @listeners[:on_in]&.each { |l| T.unsafe(l).on_in(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::WhenNode).void }
-    def visit_when_node(node)
-      @listeners[:on_when]&.each { |l| T.unsafe(l).on_when(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::InterpolatedStringNode).void }
-    def visit_interpolated_string_node(node)
-      @listeners[:on_interpolated_string]&.each { |l| T.unsafe(l).on_interpolated_string(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ArrayNode).void }
-    def visit_array_node(node)
-      @listeners[:on_array]&.each { |l| T.unsafe(l).on_array(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::CaseNode).void }
-    def visit_case_node(node)
-      @listeners[:on_case]&.each { |l| T.unsafe(l).on_case(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ForNode).void }
-    def visit_for_node(node)
-      @listeners[:on_for]&.each { |l| T.unsafe(l).on_for(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::HashNode).void }
-    def visit_hash_node(node)
-      @listeners[:on_hash]&.each { |l| T.unsafe(l).on_hash(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::SingletonClassNode).void }
-    def visit_singleton_class_node(node)
-      @listeners[:on_singleton_class]&.each { |l| T.unsafe(l).on_singleton_class(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::UnlessNode).void }
-    def visit_unless_node(node)
-      @listeners[:on_unless]&.each { |l| T.unsafe(l).on_unless(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::UntilNode).void }
-    def visit_until_node(node)
-      @listeners[:on_until]&.each { |l| T.unsafe(l).on_until(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::WhileNode).void }
-    def visit_while_node(node)
-      @listeners[:on_while]&.each { |l| T.unsafe(l).on_while(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ElseNode).void }
-    def visit_else_node(node)
-      @listeners[:on_else]&.each { |l| T.unsafe(l).on_else(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::EnsureNode).void }
-    def visit_ensure_node(node)
-      @listeners[:on_ensure]&.each { |l| T.unsafe(l).on_ensure(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::BeginNode).void }
-    def visit_begin_node(node)
-      @listeners[:on_begin]&.each { |l| T.unsafe(l).on_begin(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::StringConcatNode).void }
-    def visit_string_concat_node(node)
-      @listeners[:on_string_concat]&.each { |l| T.unsafe(l).on_string_concat(node) }
-      super
-    end
-  end
-end