ruby-lsp 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5d9c6b487aab55ce25eb2741fff92afa8ca0ee544f21374debacce7f887cc50
-  data.tar.gz: 8da9da85900753306f5e8558bc1a42f25b7173ffe1087ea70612c10ef5558e27
+  metadata.gz: f8f2f2aa1083dcc700e709ebd0bc3d3aed8f08d80943595ba3c9df332d806709
+  data.tar.gz: a065d2f6be6539c81ad117bfba7c7b4f90ead0bbce37dd936733218e3135bc67
 SHA512:
-  metadata.gz: 3dca630b9cae262f1af8d0aef0300ab7399dafd348db5f578ed7fdffb22a7afd48fe9467aa65e467fb50e16663f8fad32f1d0cc46b30819b06a6b7472700dcc0
-  data.tar.gz: f048c6c9fe14d20edefeca7ac504942af34c61699163f0d09ec54f4d80e7469e1bb1762757b96aa3d8d06a6e8168473dacfc932112b2d31ca4b380748eef8899
+  metadata.gz: de010f852e08fd72ac60a12cbb9a8666a92945c49b8a14214f0e347c9a6fbacb65770322627db22a30b573ee61f34ec18be56d625768a6c954cf447dbda63368
+  data.tar.gz: 3f47e62896899091c4a9b166937720cc535f46004827a098bfb7eaf9c31fb39bb35261077b91a01a41baa18a50482d8ffe1b8ebddabaed1ea15bc0d023e76dae

data/README.md

@@ -1,148 +1,61 @@
-![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)
+[![Build Status](https://github.com/Shopify/ruby-lsp/workflows/CI/badge.svg)](https://github.com/Shopify/ruby-lsp/actions/workflows/ci.yml)
+[![Ruby LSP extension](https://img.shields.io/badge/VS%20Code-Ruby%20LSP-success?logo=visual-studio-code)](https://marketplace.visualstudio.com/items?itemName=Shopify.ruby-lsp)
+[![Ruby DX Slack](https://img.shields.io/badge/Slack-Ruby%20DX-success?logo=slack)](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew)
 
 # Ruby LSP
 
-This gem is an implementation of the [language server protocol specification](https://microsoft.github.io/language-server-protocol/) for Ruby, used to improve editor features.
+The Ruby LSP is an implementation of the [language server protocol](https://microsoft.github.io/language-server-protocol/)
+for Ruby, used to improve rich features in editors. It is a part of a wider goal to provide a state-of-the-art
+experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
 
-# Overview
+Want to discuss Ruby developer experience? Consider joining the public
+[Ruby DX Slack workspace](https://join.slack.com/t/ruby-dx/shared_invite/zt-1s6f4y15t-v9jedZ9YUPQLM91TEJ4Gew).
 
-The intention of Ruby LSP is to provide a fast, robust and feature-rich coding environment for Ruby developers.
-
-It's part of a [wider Shopify goal](https://github.com/Shopify/vscode-shopify-ruby) to provide a state-of-the-art experience to Ruby developers using modern standards for cross-editor features, documentation and debugging.
-
-It provides many features, including:
-
-* Syntax highlighting
-* Linting and formatting
-* Code folding
-* Selection ranges
-
-It does not perform typechecking, so its features are implemented on a best-effort basis, aiming to be as accurate as possible.
-
-Planned future features include:
-
-* Auto-completion and navigation ("Go To Definition") ([prototype](https://github.com/Shopify/ruby-lsp/pull/429))
-* Support for plug-ins to extend behavior
-
-The Ruby LSP does not perform any type-checking or provide any type-related assistance, but it can be used alongside [Sorbet](https://github.com/sorbet/sorbet)'s LSP server.
+## Usage
 
-At the time of writing, these are the major differences between Ruby LSP and [Solargraph](https://solargraph.org/):
+### With VS Code
 
-* Solargraph [uses](https://solargraph.org/guides/yard) YARD documentation to gather information about your project and its gem dependencies. This provides functionality such as context-aware auto-completion and navigation ("Go To Definition")
-* Solargraph can be used as a globally installed gem, but Ruby LSP must be added to the Gemfile or gemspec if using RuboCop. (There are pros and cons to each approach)
+If using VS Code, all you have to do is install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to
+get the extra features in the editor. Do not install this gem manually.
 
-## Learn More
-
-* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+### With other editors
 
-## Usage
+See [editors](EDITORS.md) for community instructions on setting up the Ruby LSP.
 
-Install the gem. There's no need to require it, since the server is used as a standalone executable.
+The gem can be installed by doing
+```shell
+gem install ruby-lsp
+```
 
+If you decide to add the gem to the bundle, it is not necessary to require it.
 ```ruby
 group :development do
   gem "ruby-lsp", require: false
 end
 ```
 
-If using VS Code, install the [Ruby LSP extension](https://github.com/Shopify/vscode-ruby-lsp) to get the extra features
-in the editor. See [editors](https://github.com/Shopify/ruby-lsp/blob/main/EDITORS.md) for community instructions on
-setting up the Ruby LSP in different editors.
+### Documentation
 
 See the [documentation](https://shopify.github.io/ruby-lsp) for more in-depth details about the
 [supported features](https://shopify.github.io/ruby-lsp/RubyLsp/Requests.html).
 
+## Learn More
+
+* [RubyConf 2022: Improving the development experience with language servers](https://www.youtube.com/watch?v=kEfXPTm1aCI) ([Vinicius Stock](https://github.com/vinistock))
+* [Remote Ruby: Ruby Language Server with Vinicius Stock](https://remoteruby.com/221)
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/ruby-lsp.
 This project is intended to be a safe, welcoming space for collaboration, and contributors
 are expected to adhere to the
-[Contributor Covenant](https://github.com/Shopify/ruby-lsp/blob/main/CODE_OF_CONDUCT.md)
+[Contributor Covenant](CODE_OF_CONDUCT.md)
 code of conduct.
 
-### Running the test suite
-
-Run the test suite with `bin/test`.
-
-For more visibility into which tests are running, use the `SpecReporter`:
-
-`SPEC_REPORTER=1 bin/test`
-
-By default the tests run with warnings disabled to reduce noise. To enable warnings, pass `VERBOSE=1`.
-Warnings are always shown when running in CI.
-
-### Expectation testing
-
-To simplify the way we run tests over different pieces of Ruby code, we use a custom expectations test framework against a set of Ruby fixtures.
-
-We define expectations as `.exp` files, of which there are two variants:
-* `.exp.rb`, to indicate the resulting code after an operation.
-* `.exp.json`, consisting of a `result`, and an optional set of input `params`.
-
-To add a new fixture to the expectations test suite:
-
-1. Add a new fixture `my_fixture.rb` file under `test/fixtures`
-2. (optional) Add new expectations under `test/expectations/$HANDLER` for the request handlers you're concerned by
-3. Profit by running `bin/test test/requests/$HANDLER_expectations_test my_fixture`
-    * Handlers for which you added expectations will be checked with `assert_expectations`
-    * Handlers without expectations will be ran against your new test to check that nothing breaks
-
-To add a new expectations test runner for a new request handler:
-
-1. Add a new file under `test/requests/$HANDLER_expectations_test.rb` that subclasses `ExpectationsTestRunner` and calls `expectations_tests $HANDLER, "$EXPECTATIONS_DIR"` where: `$HANDLER` is the fully qualified name or your handler class and `$EXPECTATIONS_DIR` is the directory name where you want to store the expectation files.
-
-   ```rb
-   # frozen_string_literal: true
-
-   require "test_helper"
-   require "expectations/expectations_test_runner"
-
-   class $HANDLERExpectationsTest < ExpectationsTestRunner
-     expectations_tests RubyLsp::Requests::$HANDLER, "$EXPECTATIONS_DIR"
-   end
-   ```
-
-2. (optional) Override the `run_expectations` and `assert_expectations` methods if needed. See the different request handler expectations runners under `test/requests/*_expectations_test.rb` for examples.
-
-4. (optional) Add new fixtures for your handler under `test/fixtures`
-
-5. (optional) Add new expectations under `test/expectations/$HANDLER`
-   * No need to write the expectations by hand, just run the test with an empty expectation file and copy from the output.
-
-7. Profit by running, `bin/test test/expectations_test $HANDLER`
-    * Tests with expectations will be checked with `assert_expectations`
-    * Tests without expectations will be ran against your new $HANDLER to check that nothing breaks
-
-## Debugging
-
-### Debugging Tests
-
-1. Open the test file.
-2. Set a breakpoint(s) on lines by clicking next to their numbers.
-3. Open VS Code's `Run and Debug` panel.
-4. At the top of the panel, select `Minitset - current file` and click the green triangle (or press F5).
-
-### Debugging Running Ruby LSP Process
-
-1. Open the `vscode-ruby-lsp` project in VS Code.
-2. [`vscode-ruby-lsp`] Open VS Code's `Run and Debug` panel.
-3. [`vscode-ruby-lsp`] Select `Run Extension` and click the green triangle (or press F5).
-4. [`vscode-ruby-lsp`] Now VS Code will:
-    - Open another workspace as the `Extension Development Host`.
-    - Run `vscode-ruby-lsp` extension in debug mode, which will start a new `ruby-lsp` process with the `--debug` flag.
-5. Open `ruby-lsp` in VS Code.
-6. [`ruby-lsp`] Run `bin/rdbg -A` to connect to the running `ruby-lsp` process.
-7. [`ruby-lsp`] Use commands like `b <file>:<line>` or `b Class#method` to set breakpoints and type `c` to continue the process.
-8. In your `Extension Development Host` project (e.g. [`Tapioca`](https://github.com/Shopify/tapioca)), trigger the request that will hit the breakpoint.
-
-## Spell Checking
-
-VS Code users will be prompted to enable the [Code Spell Checker](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker) extension.
-By default this will be enabled for all workspaces, but you can choose to selectively enable or disable it per workspace.
-
-If you introduce a word which the spell checker does not recognize, you can add it to the `cspell.json` configuration alongside your PR.
+If you wish to contribute, see [CONTRIBUTING](CONTRIBUTING.md) for development instructions and check out our pinned
+[roadmap issue](https://github.com/Shopify/ruby-lsp/issues) for a list of tasks to get started.
 
 ## License
 
 The gem is available as open source under the terms of the
-[MIT License](https://github.com/Shopify/ruby-lsp/blob/main/LICENSE.txt).
+[MIT License](LICENSE.txt).

data/VERSION

@@ -1 +1 @@
-0.4.2
+0.5.0

data/exe/ruby-lsp

@@ -21,6 +21,11 @@ end
 require_relative "../lib/ruby_lsp/internal"
 
 if ARGV.include?("--debug")
+  if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
+    puts "Debugging is not supported on Windows"
+    exit 1
+  end
+
   sockets_dir = "/tmp/ruby-lsp-debug-sockets"
   Dir.mkdir(sockets_dir) unless Dir.exist?(sockets_dir)
   # ruby-debug-ENV["USER"] is an implicit naming pattern in ruby/debug
@@ -28,7 +33,11 @@ if ARGV.include?("--debug")
   socket_identifier = "ruby-debug-#{ENV["USER"]}-#{File.basename(Dir.pwd)}.sock"
   ENV["RUBY_DEBUG_SOCK_PATH"] = "#{sockets_dir}/#{socket_identifier}"
 
-  require "debug/open_nonstop"
+  begin
+    require "debug/open_nonstop"
+  rescue LoadError
+    warn("You need to install the debug gem to use the --debug flag")
+  end
 end
 
 RubyLsp::Server.new.start

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -0,0 +1,62 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rubocop"
+require "sorbet-runtime"
+
+module RuboCop
+  module Cop
+    module RubyLsp
+      # Prefer using `Interface`, `Transport` and `Constant` aliases
+      # within the `RubyLsp` module, without having to prefix with
+      # `LanguageServer::Protocol`
+      #
+      # @example
+      #   # bad
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #
+      #   # good
+      #   module RubyLsp
+      #     class FoldingRanges
+      #       sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
+      #       def run; end
+      #     end
+      #   end
+      class UseLanguageServerAliases < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        ALIASED_CONSTANTS = T.let([:Interface, :Transport, :Constant].freeze, T::Array[Symbol])
+
+        MSG = "Use constant alias `%{constant}`."
+
+        def_node_search :ruby_lsp_modules, <<~PATTERN
+          (module (const nil? :RubyLsp) ...)
+        PATTERN
+
+        def_node_search :lsp_constant_usages, <<~PATTERN
+          (const (const (const nil? :LanguageServer) :Protocol) {:Interface | :Transport | :Constant})
+        PATTERN
+
+        def on_new_investigation
+          return if processed_source.blank?
+
+          ruby_lsp_modules(processed_source.ast).each do |ruby_lsp_mod|
+            lsp_constant_usages(ruby_lsp_mod).each do |node|
+              lsp_const = node.children.last
+
+              next unless ALIASED_CONSTANTS.include?(lsp_const)
+
+              add_offense(node, message: format(MSG, constant: lsp_const)) do |corrector|
+                corrector.replace(node, lsp_const)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/check_docs.rb

@@ -0,0 +1,112 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "ruby_lsp/internal"
+require "objspace"
+
+module RubyLsp
+  # This rake task checks that all requests or extensions are fully documented. Add the rake task to your Rakefile and
+  # specify the absolute path for all files that must be required in order to discover all listeners
+  #
+  #   # Rakefile
+  #   request_files = FileList.new("#{__dir__}/lib/ruby_lsp/requests/*.rb") do |fl|
+  #     fl.exclude(/base_request\.rb/)
+  #   end
+  #   RubyLsp::CheckDocs.new(request_files)
+  #   # Run with bundle exec rake ruby_lsp:check_docs
+  class CheckDocs < Rake::TaskLib
+    extend T::Sig
+
+    sig { params(require_files: Rake::FileList).void }
+    def initialize(require_files)
+      super()
+
+      @name = T.let("ruby_lsp:check_docs", String)
+      @file_list = require_files
+      define_task
+    end
+
+    private
+
+    sig { void }
+    def define_task
+      desc("Checks if all Ruby LSP listeners are documented")
+      task(@name) { run_task }
+    end
+
+    sig { void }
+    def run_task
+      # Require all files configured to make sure all listeners are loaded
+      @file_list.each { |f| require(f.delete_suffix(".rb")) }
+
+      # Find all classes that inherit from BaseRequest or Listener, which are the ones we want to make sure are
+      # documented
+      features = ObjectSpace.each_object(Class).filter_map do |k|
+        klass = T.cast(k, Class)
+        klass if klass < RubyLsp::Requests::BaseRequest || klass < RubyLsp::Listener
+      end
+
+      missing_docs = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])
+
+      features.each do |klass|
+        class_name = T.must(klass.name)
+        file_path, line_number = Module.const_source_location(class_name)
+        next unless file_path && line_number
+
+        # Adjust the line number to start searching right above the class definition
+        line_number -= 2
+
+        lines = File.readlines(file_path)
+        docs = []
+
+        # Extract the documentation on top of the listener constant
+        while (line = lines[line_number]&.strip) && line.start_with?("#")
+          docs.unshift(line)
+          line_number -= 1
+        end
+
+        documentation = docs.join("\n")
+
+        if docs.empty?
+          T.must(missing_docs[class_name]) << "No documentation found"
+        elsif !%r{\(https://microsoft.github.io/language-server-protocol/specification#.*\)}.match?(documentation)
+          T.must(missing_docs[class_name]) << <<~DOCS
+            Missing specification link. Requests and extensions should include a link to the LSP specification for the
+            related feature. For example:
+
+            [Inlay hint](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
+          DOCS
+        elsif !documentation.include?("# Example")
+          T.must(missing_docs[class_name]) << <<~DOCS
+            Missing example. Requests and extensions should include a code example that explains what the feature does.
+
+            # # Example
+            # ```ruby
+            # class Foo # <- information is shown here
+            # end
+            # ```
+          DOCS
+        elsif !/\[.* demo\]\(.*\.gif\)/.match?(documentation)
+          T.must(missing_docs[class_name]) << <<~DOCS
+            Missing demonstration GIF. Each request and extension must be documented with a GIF that shows the feature
+            working. For example:
+
+            # [Inlay hint demo](../../inlay_hint.gif)
+          DOCS
+        end
+      end
+
+      if missing_docs.any?
+        warn(<<~WARN)
+          The following listeners are missing documentation:
+
+          #{missing_docs.map { |k, v| "#{k}\n\n#{v.join("\n")}" }.join("\n\n")}
+        WARN
+
+        abort
+      end
+
+      puts "All listeners are documented!"
+    end
+  end
+end

data/lib/ruby_lsp/document.rb

@@ -15,11 +15,19 @@ module RubyLsp
     sig { returns(String) }
     attr_reader :source
 
-    sig { params(source: String, encoding: String).void }
-    def initialize(source, encoding = "utf-8")
-      @cache = T.let({}, T::Hash[Symbol, T.untyped])
+    sig { returns(Integer) }
+    attr_reader :version
+
+    sig { returns(String) }
+    attr_reader :uri
+
+    sig { params(source: String, version: Integer, uri: String, encoding: String).void }
+    def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind::UTF8)
+      @cache = T.let({}, T::Hash[String, T.untyped])
       @encoding = T.let(encoding, String)
       @source = T.let(source, String)
+      @version = T.let(version, Integer)
+      @uri = T.let(uri, String)
       @unparsed_edits = T.let([], T::Array[EditShape])
       @syntax_error = T.let(false, T::Boolean)
       @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
@@ -32,10 +40,11 @@ module RubyLsp
       @source == other.source
     end
 
+    # TODO: remove this method once all nonpositional requests have been migrated to the listener pattern
     sig do
       type_parameters(:T)
         .params(
-          request_name: Symbol,
+          request_name: String,
           block: T.proc.params(document: Document).returns(T.type_parameter(:T)),
         ).returns(T.type_parameter(:T))
     end
@@ -48,8 +57,18 @@ module RubyLsp
       result
     end
 
-    sig { params(edits: T::Array[EditShape]).void }
-    def push_edits(edits)
+    sig { type_parameters(:T).params(request_name: String, value: T.type_parameter(:T)).returns(T.type_parameter(:T)) }
+    def cache_set(request_name, value)
+      @cache[request_name] = value
+    end
+
+    sig { params(request_name: String).returns(T.untyped) }
+    def cache_get(request_name)
+      @cache[request_name]
+    end
+
+    sig { params(edits: T::Array[EditShape], version: Integer).void }
+    def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
         scanner = create_scanner
@@ -60,6 +79,7 @@ module RubyLsp
         @source[start_position...end_position] = edit[:text]
       end
 
+      @version = version
       @unparsed_edits.concat(edits)
       @cache.clear
     end
@@ -68,9 +88,9 @@ module RubyLsp
     def parse
       return if @unparsed_edits.empty?
 
+      @unparsed_edits.clear
       @tree = SyntaxTree.parse(@source)
       @syntax_error = false
-      @unparsed_edits.clear
     rescue SyntaxTree::Parser::ParseError
       @syntax_error = true
     end
@@ -90,6 +110,61 @@ module RubyLsp
       Scanner.new(@source, @encoding)
     end
 
+    sig do
+      params(
+        position: PositionShape,
+        node_types: T::Array[T.class_of(SyntaxTree::Node)],
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+    end
+    def locate_node(position, node_types: [])
+      return [nil, nil] unless parsed?
+
+      locate(T.must(@tree), create_scanner.find_char_position(position))
+    end
+
+    sig do
+      params(
+        node: SyntaxTree::Node,
+        char_position: Integer,
+        node_types: T::Array[T.class_of(SyntaxTree::Node)],
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+    end
+    def locate(node, char_position, node_types: [])
+      queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
+      closest = node
+      parent = T.let(nil, T.nilable(SyntaxTree::Node))
+
+      until queue.empty?
+        candidate = queue.shift
+
+        # Skip nil child nodes
+        next if candidate.nil?
+
+        # Add the next child_nodes to the queue to be processed
+        queue.concat(candidate.child_nodes)
+
+        # Skip if the current node doesn't cover the desired position
+        loc = candidate.location
+        next unless (loc.start_char...loc.end_char).cover?(char_position)
+
+        # If the node's start character is already past the position, then we should've found the closest node
+        # already
+        break if char_position < loc.start_char
+
+        # If there are node types to filter by, and the current node is not one of those types, then skip it
+        next if node_types.any? && node_types.none? { |type| candidate.class == type }
+
+        # If the current node is narrower than or equal to the previous closest node, then it is more precise
+        closest_loc = closest.location
+        if loc.end_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
+          parent = closest
+          closest = candidate
+        end
+      end
+
+      [closest, parent]
+    end
+
     class Scanner
       extend T::Sig
 
@@ -118,7 +193,11 @@ module RubyLsp
         # The final position is the beginning of the line plus the requested column. If the encoding is UTF-16, we also
         # need to adjust for surrogate pairs
         requested_position = @pos + position[:character]
-        requested_position -= utf_16_character_position_correction(@pos, requested_position) if @encoding == "utf-16"
+
+        if @encoding == Constant::PositionEncodingKind::UTF16
+          requested_position -= utf_16_character_position_correction(@pos, requested_position)
+        end
+
         requested_position
       end
 

data/lib/ruby_lsp/event_emitter.rb

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # EventEmitter is an intermediary between our requests and Syntax Tree 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 < SyntaxTree::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(SyntaxTree::Node)).void }
+    def emit_for_target(node)
+      case node
+      when SyntaxTree::Command
+        @listeners[:on_command]&.each { |l| T.unsafe(l).on_command(node) }
+      when SyntaxTree::CallNode
+        @listeners[:on_call]&.each { |l| T.unsafe(l).on_call(node) }
+      when SyntaxTree::TStringContent
+        @listeners[:on_tstring_content]&.each { |l| T.unsafe(l).on_tstring_content(node) }
+      when SyntaxTree::ConstPathRef
+        @listeners[:on_const_path_ref]&.each { |l| T.unsafe(l).on_const_path_ref(node) }
+      when SyntaxTree::Const
+        @listeners[:on_const]&.each { |l| T.unsafe(l).on_const(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: SyntaxTree::ClassDeclaration).void }
+    def visit_class(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: SyntaxTree::ModuleDeclaration).void }
+    def visit_module(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: SyntaxTree::Command).void }
+    def visit_command(node)
+      @listeners[:on_command]&.each { |l| T.unsafe(l).on_command(node) }
+      super
+      @listeners[:after_command]&.each { |l| T.unsafe(l).after_command(node) }
+    end
+
+    sig { override.params(node: SyntaxTree::CallNode).void }
+    def visit_call(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: SyntaxTree::VCall).void }
+    def visit_vcall(node)
+      @listeners[:on_vcall]&.each { |l| T.unsafe(l).on_vcall(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::ConstPathField).void }
+    def visit_const_path_field(node)
+      @listeners[:on_const_path_field]&.each { |l| T.unsafe(l).on_const_path_field(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::TopConstField).void }
+    def visit_top_const_field(node)
+      @listeners[:on_top_const_field]&.each { |l| T.unsafe(l).on_top_const_field(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::DefNode).void }
+    def visit_def(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: SyntaxTree::VarField).void }
+    def visit_var_field(node)
+      @listeners[:on_var_field]&.each { |l| T.unsafe(l).on_var_field(node) }
+      super
+    end
+
+    sig { override.params(node: SyntaxTree::Comment).void }
+    def visit_comment(node)
+      @listeners[:on_comment]&.each { |l| T.unsafe(l).on_comment(node) }
+      super
+    end
+  end
+end