ruby-lsp-rails 0.3.31 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1d9f0d516dcad6d833e05e05defd6ba7ea0bbb3fb2b0c48e7edb9709306d854
-  data.tar.gz: 41b2f9dec0e1ba1d3d4d92a5eb1b4ad5dfd6b6d8c3e62b69822ac156f3232bfd
+  metadata.gz: 03be48ffee8e42576471456d11c3ddd9b483d1795b09adce6faf768bc0c07b8e
+  data.tar.gz: 17a31e143ed3b32899004f74bd54d0feb9f8a1284669f5b3448c18e42f2fe6ad
 SHA512:
-  metadata.gz: f4421fb81f4cffaa89abe05244ec8bcc2da8ffa0e27b5f7c310c49747d7b2e20a6eec85b58dfe77f5107bd8281ca9d2e61a5f70b2d100c5938f4a2932deedfd0
-  data.tar.gz: aa8476c6f72a66782d9d8b3225944c862f708cd9fc60fd17cf871d9f3332885bd0b7060cbf778710e9213686d5e24c1e415327c14a00a738e28f934dfae156c7
+  metadata.gz: 7332a6411c36903267d8bcb448513eb21636205ca13290d71c2eeee26efa326c40dca280d639332428e863638e9db0fe12ffbd35f0a5e517ccc1ed777ce6a59b
+  data.tar.gz: b1c3e40c0def28339e948db1d336754197e697d1aa483b83e87786fa834f83f3c0088cbf7c3699dc7783df1f20c3ad6a8b1d104ab63e60c7bfb6a4a6962e7fa3

data/Rakefile

@@ -16,4 +16,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task default: [:"db:setup", :test]
+task default: :test

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -13,126 +13,131 @@ require_relative "hover"
 require_relative "code_lens"
 require_relative "document_symbol"
 require_relative "definition"
+require_relative "rails_test_style"
 require_relative "completion"
 require_relative "indexing_enhancement"
 
 module RubyLsp
   module Rails
     class Addon < ::RubyLsp::Addon
-      extend T::Sig
-
       RUN_MIGRATIONS_TITLE = "Run Migrations"
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
         # We first initialize the client as a NullClient, so that we can start the server in a background thread. Until
         # the real client is initialized, features that depend on it will not be blocked by using the NullClient
-        @rails_runner_client = T.let(NullClient.new, RunnerClient)
-        @global_state = T.let(nil, T.nilable(GlobalState))
-        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
-        @addon_mutex = T.let(Mutex.new, Mutex)
-        @client_mutex = T.let(Mutex.new, Mutex)
+        @rails_runner_client = NullClient.new #: RunnerClient
+        @global_state = nil #: GlobalState?
+        @outgoing_queue = nil #: Thread::Queue?
+        @settings = {
+          enablePendingMigrationsPrompt: true,
+        } #: Hash[Symbol, untyped],
+
+        @addon_mutex = Mutex.new #: Mutex
+        @client_mutex = Mutex.new #: Mutex
         @client_mutex.lock
 
         Thread.new do
           @addon_mutex.synchronize do
             # We need to ensure the Rails client is fully loaded before we activate the server addons
-            @client_mutex.synchronize { @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue)) }
+            @client_mutex.synchronize do
+              @rails_runner_client = RunnerClient.create_client(
+                @outgoing_queue, #: as !nil
+                @global_state, #: as !nil
+              )
+            end
             offer_to_run_pending_migrations
           end
         end
       end
 
-      sig { returns(RunnerClient) }
+      #: -> RunnerClient
       def rails_runner_client
         @addon_mutex.synchronize { @rails_runner_client }
       end
 
-      sig { override.params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      # @override
+      #: (GlobalState global_state, Thread::Queue outgoing_queue) -> void
       def activate(global_state, outgoing_queue)
         @global_state = global_state
         @outgoing_queue = outgoing_queue
         @outgoing_queue << Notification.window_log_message("Activating Ruby LSP Rails add-on v#{VERSION}")
 
+        addon_settings = @global_state.settings_for_addon(name)
+        @settings.merge!(addon_settings) if addon_settings
+
         register_additional_file_watchers(global_state: global_state, outgoing_queue: outgoing_queue)
 
         # Start booting the real client in a background thread. Until this completes, the client will be a NullClient
         @client_mutex.unlock
       end
 
-      sig { override.void }
+      # @override
+      #: -> void
       def deactivate
         @rails_runner_client.shutdown
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def version
         VERSION
       end
 
-      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
+      # @override
+      #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
+      def create_discover_tests_listener(response_builder, dispatcher, uri)
+        return unless @global_state
+
+        RailsTestStyle.new(response_builder, @global_state, dispatcher, uri)
       end
-      def create_code_lens_listener(response_builder, uri, dispatcher)
-        CodeLens.new(@rails_runner_client, T.must(@global_state), response_builder, uri, dispatcher)
+
+      # @override
+      #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+      def resolve_test_commands(items)
+        RailsTestStyle.resolve_test_commands(items)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::Hover,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-        ).void
+      # Creates a new CodeLens listener. This method is invoked on every CodeLens request
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
+      def create_code_lens_listener(response_builder, uri, dispatcher)
+        return unless @global_state
+
+        CodeLens.new(@rails_runner_client, @global_state, response_builder, uri, dispatcher)
       end
+
+      # @override
+      #: (ResponseBuilders::Hover response_builder, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
       def create_hover_listener(response_builder, node_context, dispatcher)
-        Hover.new(@rails_runner_client, response_builder, node_context, T.must(@global_state), dispatcher)
-      end
+        return unless @global_state
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::DocumentSymbol,
-          dispatcher: Prism::Dispatcher,
-        ).returns(Object)
+        Hover.new(@rails_runner_client, response_builder, node_context, @global_state, dispatcher)
       end
+
+      # @override
+      #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> Object
       def create_document_symbol_listener(response_builder, dispatcher)
         DocumentSymbol.new(response_builder, dispatcher)
       end
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location, Interface::LocationLink
-          )],
-          uri: URI::Generic,
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher) -> void
       def create_definition_listener(response_builder, uri, node_context, dispatcher)
-        index = T.must(@global_state).index
-        Definition.new(@rails_runner_client, response_builder, node_context, index, dispatcher)
-      end
+        return unless @global_state
 
-      sig do
-        override.params(
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
+        Definition.new(@rails_runner_client, response_builder, node_context, @global_state.index, dispatcher)
       end
+
+      # @override
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def create_completion_listener(response_builder, node_context, dispatcher, uri)
         Completion.new(@rails_runner_client, response_builder, node_context, dispatcher, uri)
       end
 
-      sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
+      #: (Array[{uri: String, type: Integer}] changes) -> void
       def workspace_did_change_watched_files(changes)
         if changes.any? { |c| c[:uri].end_with?("db/schema.rb") || c[:uri].end_with?("structure.sql") }
           @rails_runner_client.trigger_reload
@@ -146,12 +151,14 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def name
         "Ruby LSP Rails"
       end
 
-      sig { override.params(title: String).void }
+      # @override
+      #: (String title) -> void
       def handle_window_show_message_response(title)
         if title == RUN_MIGRATIONS_TITLE
 
@@ -178,7 +185,7 @@ module RubyLsp
 
       private
 
-      sig { params(id: String, title: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
+      #: (String id, String title, ?percentage: Integer?, ?message: String?) -> void
       def begin_progress(id, title, percentage: nil, message: nil)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
@@ -196,21 +203,21 @@ module RubyLsp
         )
       end
 
-      sig { params(id: String, percentage: T.nilable(Integer), message: T.nilable(String)).void }
-      def report_progress(id,  percentage: nil, message: nil)
+      #: (String id, ?percentage: Integer?, ?message: String?) -> void
+      def report_progress(id, percentage: nil, message: nil)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
         @outgoing_queue << Notification.progress_report(id, percentage: percentage, message: message)
       end
 
-      sig { params(id: String).void }
+      #: (String id) -> void
       def end_progress(id)
         return unless @global_state&.client_capabilities&.supports_progress && @outgoing_queue
 
         @outgoing_queue << Notification.progress_end(id)
       end
 
-      sig { params(global_state: GlobalState, outgoing_queue: Thread::Queue).void }
+      #: (global_state: GlobalState, outgoing_queue: Thread::Queue) -> void
       def register_additional_file_watchers(global_state:, outgoing_queue:)
         return unless global_state.client_capabilities.supports_watching_files
 
@@ -231,7 +238,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(Interface::FileSystemWatcher) }
+      #: -> Interface::FileSystemWatcher
       def structure_sql_file_watcher
         Interface::FileSystemWatcher.new(
           glob_pattern: "**/*structure.sql",
@@ -239,7 +246,7 @@ module RubyLsp
         )
       end
 
-      sig { returns(Interface::FileSystemWatcher) }
+      #: -> Interface::FileSystemWatcher
       def fixture_file_watcher
         Interface::FileSystemWatcher.new(
           glob_pattern: "**/fixtures/**/*.{yml,yaml,yml.erb,yaml.erb}",
@@ -247,10 +254,11 @@ module RubyLsp
         )
       end
 
-      sig { void }
+      #: -> void
       def offer_to_run_pending_migrations
         return unless @outgoing_queue
         return unless @global_state&.client_capabilities&.window_show_message_supports_extra_properties
+        return unless @settings[:enablePendingMigrationsPrompt]
 
         migration_message = @rails_runner_client.pending_migrations_message
         return unless migration_message

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -72,27 +72,18 @@ module RubyLsp
     # Note: Complex routing configurations may not be supported.
     #
     class CodeLens
-      extend T::Sig
       include Requests::Support::Common
       include ActiveSupportTestCaseHelper
 
-      sig do
-        params(
-          client: RunnerClient,
-          global_state: GlobalState,
-          response_builder:  ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
-          uri: URI::Generic,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (RunnerClient, GlobalState, ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens], URI::Generic, Prism::Dispatcher) -> void
       def initialize(client, global_state, response_builder, uri, dispatcher)
         @client = client
         @global_state = global_state
         @response_builder = response_builder
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
-        @group_id = T.let(1, Integer)
-        @group_id_stack = T.let([], T::Array[Integer])
-        @constant_name_stack = T.let([], T::Array[[String, T.nilable(String)]])
+        @path = uri.to_standardized_path #: String?
+        @group_id = 1 #: Integer
+        @group_id_stack = [] #: Array[Integer]
+        @constant_name_stack = [] #: Array[[String, String?]]
 
         dispatcher.register(
           self,
@@ -105,10 +96,12 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
-        content = extract_test_case_name(node)
+        # Remove this method once the rollout is complete
+        return if @global_state.enabled_feature?(:fullTestDiscovery)
 
+        content = extract_test_case_name(node)
         return unless content
 
         line_number = node.location.start_line
@@ -117,14 +110,17 @@ module RubyLsp
       end
 
       # Although uncommon, Rails tests can be written with the classic "def test_name" syntax.
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
-        method_name = node.name.to_s
-
-        if method_name.start_with?("test_")
-          line_number = node.location.start_line
-          command = "#{test_command} #{@path}:#{line_number}"
-          add_test_code_lens(node, name: method_name, command: command, kind: :example)
+        # Remove this entire unless block once the rollout is complete
+        unless @global_state.enabled_feature?(:fullTestDiscovery)
+          method_name = node.name.to_s
+
+          if method_name.start_with?("test_")
+            line_number = node.location.start_line
+            command = "#{test_command} #{@path}:#{line_number}"
+            add_test_code_lens(node, name: method_name, command: command, kind: :example)
+          end
         end
 
         if controller?
@@ -133,7 +129,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_enter(node)
         class_name = node.constant_path.slice
         superclass_name = node.superclass&.slice
@@ -143,7 +139,8 @@ module RubyLsp
         # back in a controller context. This part is used in other places in the LSP
         @constant_name_stack << [class_name, superclass_name]
 
-        if class_name.end_with?("Test")
+        # Remove this entire if block once the rollout is complete
+        if class_name.end_with?("Test") && !@global_state.enabled_feature?(:fullTestDiscovery)
           fully_qualified_name = @constant_name_stack.map(&:first).join("::")
           command = "#{test_command} #{@path} --name \"/#{Shellwords.escape(fully_qualified_name)}(#|::)/\""
           add_test_code_lens(node, name: class_name, command: command, kind: :group)
@@ -157,30 +154,32 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ClassNode).void }
+      #: (Prism::ClassNode node) -> void
       def on_class_node_leave(node)
         class_name = node.constant_path.slice
 
         if class_name.end_with?("Test")
           @group_id_stack.pop
         end
+        # Remove everything but the `@constant_name_stack.pop` once the rollout is complete
+        return if @global_state.enabled_feature?(:fullTestDiscovery)
 
         @constant_name_stack.pop
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_enter(node)
         @constant_name_stack << [node.constant_path.slice, nil]
       end
 
-      sig { params(node: Prism::ModuleNode).void }
+      #: (Prism::ModuleNode node) -> void
       def on_module_node_leave(node)
         @constant_name_stack.pop
       end
 
       private
 
-      sig { returns(T.nilable(T::Boolean)) }
+      #: -> bool?
       def controller?
         class_name, superclass_name = @constant_name_stack.last
         return false unless class_name && superclass_name
@@ -188,7 +187,7 @@ module RubyLsp
         class_name.end_with?("Controller") && superclass_name.end_with?("Controller")
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def add_jump_to_view(node)
         class_name = @constant_name_stack.map(&:first).join("::")
         action_name = node.name
@@ -216,9 +215,9 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::DefNode).void }
+      #: (Prism::DefNode node) -> void
       def add_route_code_lens_to_action(node)
-        class_name, _ = T.must(@constant_name_stack.last)
+        class_name, _ = @constant_name_stack.last #: as !nil
         route = @client.route(controller: class_name, action: node.name.to_s)
         return unless route
 
@@ -233,22 +232,24 @@ module RubyLsp
         )
       end
 
-      sig { returns(String) }
+      #: -> String
       def test_command
         "#{RbConfig.ruby} bin/rails test"
       end
 
-      sig { returns(String) }
+      #: -> String
       def migrate_command
         "#{RbConfig.ruby} bin/rails db:migrate"
       end
 
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def migration_version
-        File.basename(T.must(@path)).split("_").first
+        File.basename(
+          @path, #: as !nil
+        ).split("_").first
       end
 
-      sig { params(node: Prism::Node, name: String, command: String).void }
+      #: (Prism::Node node, name: String, command: String) -> void
       def add_migrate_code_lens(node, name:, command:)
         return unless @path
 
@@ -261,7 +262,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
+      #: (Prism::Node node, name: String, command: String, kind: Symbol) -> void
       def add_test_code_lens(node, name:, command:, kind:)
         return unless @path
         return unless @global_state.test_library == "rails"

data/lib/ruby_lsp/ruby_lsp_rails/completion.rb

@@ -4,18 +4,10 @@
 module RubyLsp
   module Rails
     class Completion
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        override.params(
-          client: RunnerClient,
-          response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          node_context: NodeContext,
-          dispatcher: Prism::Dispatcher,
-          uri: URI::Generic,
-        ).void
-      end
+      # @override
+      #: (RunnerClient client, ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, NodeContext node_context, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
       def initialize(client, response_builder, node_context, dispatcher, uri)
         @response_builder = response_builder
         @client = client
@@ -26,7 +18,7 @@ module RubyLsp
         )
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         call_node = @node_context.call_node
         return unless call_node
@@ -39,13 +31,13 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode, receiver: Prism::ConstantReadNode).void }
+      #: (node: Prism::CallNode, receiver: Prism::ConstantReadNode) -> void
       def handle_active_record_where_completions(node:, receiver:)
         resolved_class = @client.model(receiver.name.to_s)
         return if resolved_class.nil?
 
-        arguments = T.must(@node_context.call_node).arguments&.arguments
-        indexed_call_node_args = T.let({}, T::Hash[String, Prism::Node])
+        arguments = @node_context.call_node&.arguments&.arguments
+        indexed_call_node_args = {} #: Hash[String, Prism::Node]
 
         if arguments
           indexed_call_node_args = index_call_node_args(arguments: arguments)
@@ -70,7 +62,7 @@ module RubyLsp
         end
       end
 
-      sig { params(arguments: T::Array[Prism::Node]).returns(T::Hash[String, Prism::Node]) }
+      #: (arguments: Array[Prism::Node]) -> Hash[String, Prism::Node]
       def index_call_node_args(arguments:)
         indexed_call_node_args = {}
         arguments.each do |argument|

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -28,41 +28,30 @@ module RubyLsp
     # - If using `constraints`, the route can only be found if the constraints are met.
     # - Changes to routes won't be picked up until the server is restarted.
     class Definition
-      extend T::Sig
       include Requests::Support::Common
 
-      sig do
-        params(
-          client: RunnerClient,
-          response_builder: RubyLsp::ResponseBuilders::CollectionResponseBuilder[T.any(
-            Interface::Location, Interface::LocationLink
-          )],
-          node_context: NodeContext,
-          index: RubyIndexer::Index,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (RunnerClient client, RubyLsp::ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, NodeContext node_context, RubyIndexer::Index index, Prism::Dispatcher dispatcher) -> void
       def initialize(client, response_builder, node_context, index, dispatcher)
         @client = client
         @response_builder = response_builder
         @node_context = node_context
-        @nesting = T.let(node_context.nesting, T::Array[String])
+        @nesting = node_context.nesting #: Array[String]
         @index = index
 
         dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
       end
 
-      sig { params(node: Prism::SymbolNode).void }
+      #: (Prism::SymbolNode node) -> void
       def on_symbol_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      sig { params(node: Prism::StringNode).void }
+      #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
         handle_possible_dsl(node)
       end
 
-      sig { params(node: T.any(Prism::SymbolNode, Prism::StringNode)).void }
+      #: ((Prism::SymbolNode | Prism::StringNode) node) -> void
       def handle_possible_dsl(node)
         node = @node_context.call_node
         return unless node
@@ -79,7 +68,7 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         return unless self_receiver?(node)
 
@@ -94,7 +83,7 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_callback(node)
         arguments = node.arguments&.arguments
         return unless arguments&.any?
@@ -113,14 +102,14 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_association(node)
         first_argument = node.arguments&.arguments&.first
         return unless first_argument.is_a?(Prism::SymbolNode)
 
         association_name = first_argument.unescaped
 
-        result = @client.association_target_location(
+        result = @client.association_target(
           model_name: @nesting.join("::"),
           association_name: association_name,
         )
@@ -130,15 +119,17 @@ module RubyLsp
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
-      sig { params(node: Prism::CallNode).void }
+      #: (Prism::CallNode node) -> void
       def handle_route(node)
-        result = @client.route_location(T.must(node.message))
+        result = @client.route_location(
+          node.message, #: as !nil
+        )
         return unless result
 
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))
       end
 
-      sig { params(name: String).void }
+      #: (String name) -> void
       def collect_definitions(name)
         methods = @index.resolve_method(name, @nesting.join("::"))
         return unless methods