ruby-lsp 0.27.0.beta2 → 0.27.0.beta3

data/lib/ruby_lsp/listeners/definition.rb

@@ -106,7 +106,7 @@ module RubyLsp
 
       #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         handle_constant_definition(name)
@@ -114,7 +114,7 @@ module RubyLsp
 
       #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         handle_constant_definition(name)
@@ -302,6 +302,9 @@ module RubyLsp
         return unless declaration
 
         Array(declaration).each do |decl|
+          next if decl.is_a?(Rubydex::Method) &&
+            !method_reachable_from_call_site?(decl, receiver_type, @graph, @node_context)
+
           decl.definitions.each do |definition|
             location = definition.location
             uri = URI(location.uri)
@@ -367,13 +370,7 @@ module RubyLsp
       def handle_constant_definition(value)
         declaration = @graph.resolve_constant(value, @node_context.nesting)
         return unless declaration
-
-        # [RUBYDEX] TODO: temporarily commented out until we have the visibility API
-        #
-        # We should only allow jumping to the definition of private constants if the constant is defined in the same
-        # namespace as the reference
-        #
-        # return if declaration.private? && declaration.name != "#{@node_context.fully_qualified_name}::#{value}"
+        return unless constant_reachable_from_call_site?(declaration, value, @node_context)
 
         declaration.definitions.each do |definition|
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an

data/lib/ruby_lsp/listeners/hover.rb

@@ -15,7 +15,6 @@ module RubyLsp
       def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level, position) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
-        @index = global_state.index #: RubyIndexer::Index
         @graph = global_state.graph #: Rubydex::Graph
         @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @path = uri.to_standardized_path #: String?
@@ -117,7 +116,7 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         return unless @sorbet_level.ignore?
 
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         generate_hover(name, node.location)
@@ -134,7 +133,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return unless @sorbet_level.ignore?
 
-        name = RubyIndexer::Index.constant_name(node)
+        name = constant_name(node)
         return if name.nil?
 
         generate_hover(name, node.location)
@@ -457,20 +456,22 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
-        return unless methods
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        first_method = methods.first #: as !nil
+        method = owner.find_member("#{message}()", only_inherited: inherited_only)
+        return unless method.is_a?(Rubydex::Method)
+        return unless method_reachable_from_call_site?(method, type, @graph, @node_context)
 
-        title = "#{message}#{first_method.decorated_parameters}"
-        title << first_method.formatted_signatures
+        title = +"#{message}#{method.decorated_parameters}"
+        title << method.formatted_signatures
 
         if type.is_a?(TypeInferrer::GuessedType)
           title << "\n\nGuessed receiver: #{type.name}"
           @response_builder.push("[Learn more about guessed types](#{GUESSED_TYPES_URL})\n", category: :links)
         end
 
-        categorized_markdown_from_index_entries(title, methods).each do |category, content|
+        categorized_markdown_from_definitions(title, method.definitions).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end
@@ -513,6 +514,7 @@ module RubyLsp
       def generate_hover(name, location)
         declaration = @graph.resolve_constant(name, @node_context.nesting)
         return unless declaration
+        return unless constant_reachable_from_call_site?(declaration, name, @node_context)
 
         categorized_markdown_from_definitions(declaration.name, declaration.definitions).each do |category, content|
           @response_builder.push(content, category: category)

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -11,7 +11,7 @@ module RubyLsp
         @sorbet_level = sorbet_level
         @response_builder = response_builder
         @global_state = global_state
-        @index = global_state.index #: RubyIndexer::Index
+        @graph = global_state.graph #: Rubydex::Graph
         @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
@@ -27,18 +27,17 @@ module RubyLsp
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
-        methods = @index.resolve_method(message, type.name)
-        return unless methods
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
 
-        target_method = methods.first
-        return unless target_method
+        target_method = owner.find_member("#{message}()")
+        return unless target_method.is_a?(Rubydex::Method)
 
         signatures = target_method.signatures
 
-        # If the method doesn't have any parameters, there's no need to show signature help
+        # If the method doesn't have any signatures, there's nothing to show
         return if signatures.empty?
 
-        name = target_method.name
         title = +""
 
         extra_links = if type.is_a?(TypeInferrer::GuessedType)
@@ -49,7 +48,7 @@ module RubyLsp
         active_signature, active_parameter = determine_active_signature_and_parameter(node, signatures)
 
         signature_help = Interface::SignatureHelp.new(
-          signatures: generate_signatures(signatures, name, methods, title, extra_links),
+          signatures: generate_signatures(signatures, message, target_method, title, extra_links),
           active_signature: active_signature,
           active_parameter: active_parameter,
         )
@@ -58,7 +57,7 @@ module RubyLsp
 
       private
 
-      #: (Prism::CallNode node, Array[RubyIndexer::Entry::Signature] signatures) -> [Integer, Integer]
+      #: (Prism::CallNode node, Array[Rubydex::Signature] signatures) -> [Integer, Integer]
       def determine_active_signature_and_parameter(node, signatures)
         arguments_node = node.arguments
         arguments = arguments_node&.arguments || []
@@ -86,15 +85,15 @@ module RubyLsp
         [active_sig_index, active_parameter]
       end
 
-      #: (Array[RubyIndexer::Entry::Signature] signatures, String method_name, Array[RubyIndexer::Entry] methods, String title, String? extra_links) -> Array[Interface::SignatureInformation]
-      def generate_signatures(signatures, method_name, methods, title, extra_links)
+      #: (Array[Rubydex::Signature] signatures, String method_name, Rubydex::Method method, String title, String? extra_links) -> Array[Interface::SignatureInformation]
+      def generate_signatures(signatures, method_name, method, title, extra_links)
         signatures.map do |signature|
           Interface::SignatureInformation.new(
             label:  "#{method_name}(#{signature.format})",
             parameters: signature.parameters.map { |param| Interface::ParameterInformation.new(label: param.name) },
             documentation: Interface::MarkupContent.new(
               kind: "markdown",
-              value: markdown_from_index_entries(title, methods, extra_links: extra_links),
+              value: markdown_from_definitions(title, method.definitions, extra_links: extra_links),
             ),
           )
         end

data/lib/ruby_lsp/listeners/test_discovery.rb

@@ -56,7 +56,23 @@ module RubyLsp
 
       #: (String? name) -> String
       def calc_fully_qualified_name(name)
-        RubyIndexer::Index.actual_nesting(@nesting, name).join("::")
+        parts = name ? @nesting + [name] : @nesting
+        return "" if parts.empty?
+
+        last = parts.last #: as !nil
+        rest = parts[0...-1] #: as !nil
+
+        resolved = @graph.resolve_constant(last, rest)
+        return resolved.name if resolved
+
+        # Fallback for unresolved constants (e.g. dynamic references): preserve top-level reset semantics by
+        # truncating at the first `::`-prefixed part when scanning from the innermost out.
+        corrected = []
+        parts.reverse_each do |part|
+          corrected.prepend(part.delete_prefix("::"))
+          break if part.start_with?("::")
+        end
+        corrected.join("::")
       end
 
       #: (Prism::ClassNode node, String fully_qualified_name) -> Array[String]

data/lib/ruby_lsp/listeners/test_style.rb

@@ -220,7 +220,7 @@ module RubyLsp
         name = node.name.to_s
         return unless name.start_with?("test_")
 
-        current_group_name = RubyIndexer::Index.actual_nesting(@nesting, nil).join("::")
+        current_group_name = calc_fully_qualified_name(nil)
         parent = @parent_stack.last
         return unless parent.is_a?(Requests::Support::TestItem)
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -16,6 +16,12 @@ module RubyLsp
     class CompletionResolve < Request
       include Requests::Support::Common
 
+      METHOD_KINDS = [
+        Constant::CompletionItemKind::METHOD,
+        Constant::CompletionItemKind::CONSTRUCTOR,
+        Constant::CompletionItemKind::FUNCTION,
+      ].freeze #: Array[Integer]
+
       # set a limit on the number of documentation entries returned, to avoid rendering performance issues
       # https://github.com/Shopify/ruby-lsp/pull/1798
       MAX_DOCUMENTATION_ENTRIES = 10
@@ -23,7 +29,6 @@ module RubyLsp
       #: (GlobalState global_state, Hash[Symbol, untyped] item) -> void
       def initialize(global_state, item)
         super()
-        @index = global_state.index #: RubyIndexer::Index
         @graph = global_state.graph #: Rubydex::Graph
         @item = item
       end
@@ -32,6 +37,8 @@ module RubyLsp
       #: -> Hash[Symbol, untyped]
       def perform
         return @item if @item.dig(:data, :skip_resolve)
+        return keyword_resolve if @item.dig(:data, :keyword)
+        return @item if @item[:kind] == Constant::CompletionItemKind::FILE
 
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
@@ -40,48 +47,61 @@ module RubyLsp
         #
         # For example, forgetting to return the `insertText` included in the original item will make the editor use the
         # `label` for the text edit instead
-        label = @item[:label].dup
-        return keyword_resolve if @item.dig(:data, :keyword)
+        declaration = resolve_declaration
+        return @item unless declaration
 
-        entries = @index[label] || []
-
-        owner_name = @item.dig(:data, :owner_name)
-
-        if owner_name
-          entries = entries.select do |entry|
-            (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable) ||
-            entry.is_a?(RubyIndexer::Entry::MethodAlias) || entry.is_a?(RubyIndexer::Entry::ClassVariable)) &&
-              entry.owner&.name == owner_name
-          end
-        end
-
-        first_entry = entries.first #: as !nil
+        guessed_type = @item.dig(:data, :guessed_type)
+        title = @item[:label].dup
 
-        if first_entry.is_a?(RubyIndexer::Entry::Member)
-          label = +"#{label}#{first_entry.decorated_parameters}"
-          label << first_entry.formatted_signatures
+        if declaration.is_a?(Rubydex::Method)
+          title << declaration.decorated_parameters
+          title << declaration.formatted_signatures
         end
 
-        guessed_type = @item.dig(:data, :guessed_type)
-
         extra_links = if guessed_type
-          label << "\n\nGuessed receiver: #{guessed_type}"
+          title << "\n\nGuessed receiver: #{guessed_type}"
           "[Learn more about guessed types](#{GUESSED_TYPES_URL})"
         end
 
-        unless @item[:kind] == Constant::CompletionItemKind::FILE
-          @item[:documentation] = Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES, extra_links: extra_links),
-          )
-        end
+        @item[:documentation] = Interface::MarkupContent.new(
+          kind: "markdown",
+          value: markdown_from_definitions(
+            title,
+            declaration.definitions,
+            MAX_DOCUMENTATION_ENTRIES,
+            extra_links: extra_links,
+          ),
+        )
 
         @item
       end
 
       private
 
-      #: () -> Hash[Symbol, untyped]
+      # Find the Rubydex declaration that matches the completion item. Constants are looked up by their fully qualified
+      # name (set when the completion was produced); members (methods, instance/class variables) are resolved by walking
+      # the owner namespace and its ancestors so that inherited and aliased members are surfaced correctly.
+      #: -> Rubydex::Declaration?
+      def resolve_declaration
+        data = @item[:data] || {}
+
+        if (fully_qualified_name = data[:fully_qualified_name])
+          @graph[fully_qualified_name]
+        elsif (owner_name = data[:owner_name])
+          owner = @graph[owner_name]
+          return unless owner.is_a?(Rubydex::Namespace)
+
+          member_name = if METHOD_KINDS.include?(@item[:kind])
+            "#{@item[:label]}()"
+          else
+            @item[:label]
+          end
+
+          owner.find_member(member_name)
+        end
+      end
+
+      #: -> Hash[Symbol, untyped]
       def keyword_resolve
         keyword = @graph.keyword(@item[:label])
 

data/lib/ruby_lsp/requests/references.rb

@@ -145,7 +145,7 @@ module RubyLsp
         end
         return if declarations.empty?
 
-        collect_references(method_references_for(message), declarations, include_declarations)
+        collect_references(method_references_for(message, declarations), declarations, include_declarations)
       end
 
       # Handles instance and class variable references. Resolves the receiver type from the node context to locate
@@ -187,14 +187,28 @@ module RubyLsp
         declaration = owner.find_member("#{method_name}()")
         return unless declaration
 
-        collect_references(method_references_for(method_name), [declaration], include_declarations)
+        collect_references(method_references_for(method_name, [declaration]), [declaration], include_declarations)
       end
 
-      # Method references in Rubydex are not yet resolved to specific declarations, so we filter from the global
-      # method references by name
-      #: (String) -> Array[Rubydex::MethodReference]
-      def method_references_for(method_name)
-        @graph.method_references.select { |reference| reference.name == method_name }
+      #: (String, Array[Rubydex::Declaration]) -> Array[Rubydex::MethodReference]
+      def method_references_for(method_name, declarations)
+        target_owner_names = declarations.map do |d|
+          d.owner #: as Rubydex::Namespace
+            .name
+        end
+
+        @graph.method_references.select do |reference|
+          next false unless reference.name == method_name
+
+          receiver = reference.receiver
+          next true if receiver.nil? || target_owner_names.empty?
+
+          if receiver.is_a?(Rubydex::Namespace)
+            receiver.ancestors.any? { |ancestor| target_owner_names.include?(ancestor.name) }
+          else
+            target_owner_names.include?(receiver.name)
+          end
+        end
       end
 
       #: (Enumerable[Rubydex::Reference] references, Array[Rubydex::Declaration] declarations, bool include_declarations) -> void

data/lib/ruby_lsp/requests/rename.rb

@@ -54,7 +54,7 @@ module RubyLsp
 
         target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode
 
-        name = RubyIndexer::Index.constant_name(target)
+        name = constant_name(target)
         return unless name
 
         declaration = @graph.resolve_constant(name, node_context.nesting)

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

@@ -23,7 +23,7 @@ module RubyLsp
           )
         end
 
-        #: ((Prism::Location | RubyIndexer::Location) location) -> Interface::Range
+        #: ((Prism::Location | Rubydex::Location) location) -> Interface::Range
         def range_from_location(location)
           Interface::Range.new(
             start: Interface::Position.new(
@@ -77,6 +77,44 @@ module RubyLsp
           receiver.nil? || receiver.is_a?(Prism::SelfNode)
         end
 
+        # Returns true when a constant declaration is reachable from the call site. Private constants are only
+        # reachable from within the namespace where they are defined.
+        #
+        #: (Rubydex::Declaration declaration, String value, NodeContext node_context) -> bool
+        def constant_reachable_from_call_site?(declaration, value, node_context)
+          return true unless declaration.is_a?(Rubydex::Visibility) && declaration.private?
+
+          declaration.name == "#{node_context.fully_qualified_name}::#{value}"
+        end
+
+        # Returns true when a method is reachable from the call site, considering visibility and receiver type.
+        # A method is reachable when:
+        # - there's no concrete receiver type to compare against
+        # - the call site is inside the receiver's own namespace (implicit/self call)
+        # - it is public
+        # - it is protected and the call site's class is in the same hierarchy as the method's defining class
+        #
+        # The `method_decl` is duck-typed to support `Rubydex::Method`, `RubyIndexer::Entry::Member` and
+        # `RubyIndexer::Entry::MethodAlias`. All respond to `public?`, `private?` and `owner` (an object with a
+        # `name` attribute).
+        #
+        #: (Rubydex::Method method_decl, TypeInferrer::Type? receiver_type, Rubydex::Graph graph, NodeContext node_context) -> bool
+        def method_reachable_from_call_site?(method_decl, receiver_type, graph, node_context)
+          return true unless receiver_type
+
+          caller_namespace = node_context.fully_qualified_name
+          return true if caller_namespace == receiver_type.name
+
+          return true if method_decl.public?
+          return false if method_decl.private?
+
+          caller_declaration = graph[caller_namespace]
+          return false unless caller_declaration.is_a?(Rubydex::Namespace)
+
+          owner_name = method_decl.owner.name
+          caller_declaration.ancestors.any? { |ancestor| ancestor.name == owner_name }
+        end
+
         #: (String, Enumerable[Rubydex::Definition], ?Integer?) -> Hash[Symbol, String]
         def categorized_markdown_from_definitions(title, definitions, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"
@@ -87,17 +125,22 @@ module RubyLsp
             # For Markdown links, we need 1 based display locations
             loc = definition.location.to_display
             uri = URI(loc.uri)
-            file_name = if uri.scheme == "untitled"
+
+            file_name = case uri.scheme
+            when "file"
+              full_path = uri.full_path #: as !nil
+              File.basename(full_path)
+            when "untitled"
               uri.opaque #: as !nil
-            else
-              File.basename(
-                uri.full_path, #: as !nil
-              )
             end
 
-            # The format for VS Code file URIs is `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
-            string_uri = "#{loc.uri}#L#{loc.start_line},#{loc.start_column}-#{loc.end_line},#{loc.end_column}"
-            file_links << "[#{file_name}](#{string_uri})"
+            # Omit the link for magic schemes like rubydex:built-in
+            if file_name
+              # The format for VS Code file URIs is `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
+              string_uri = "#{loc.uri}#L#{loc.start_line},#{loc.start_column}-#{loc.end_line},#{loc.end_column}"
+              file_links << "[#{file_name}](#{string_uri})"
+            end
+
             content << "\n\n#{definition.comments.map { |comment| comment.string.delete_prefix("# ") }.join("\n")}" unless definition.comments.empty?
           end
 
@@ -117,42 +160,9 @@ module RubyLsp
           }
         end
 
-        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries) -> Hash[Symbol, String]
-        def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
-          markdown_title = "```ruby\n#{title}\n```"
-          definitions = []
-          content = +""
-          entries = Array(entries)
-          entries_to_format = max_entries ? entries.take(max_entries) : entries
-          entries_to_format.each do |entry|
-            loc = entry.location
-
-            # We always handle locations as zero based. However, for file links in Markdown we need them to be one
-            # based, which is why instead of the usual subtraction of 1 to line numbers, we are actually adding 1 to
-            # columns. The format for VS Code file URIs is
-            # `file:///path/to/file.rb#Lstart_line,start_column-end_line,end_column`
-            uri = "#{entry.uri}#L#{loc.start_line},#{loc.start_column + 1}-#{loc.end_line},#{loc.end_column + 1}"
-            definitions << "[#{entry.file_name}](#{uri})"
-            content << "\n\n#{entry.comments}" unless entry.comments.empty?
-          end
-
-          additional_entries_text = if max_entries && entries.length > max_entries
-            additional = entries.length - max_entries
-            " | #{additional} other#{additional > 1 ? "s" : ""}"
-          else
-            ""
-          end
-
-          {
-            title: markdown_title,
-            links: "**Definitions**: #{definitions.join(" | ")}#{additional_entries_text}",
-            documentation: content,
-          }
-        end
-
-        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries, ?extra_links: String?) -> String
-        def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
-          categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
+        #: (String title, Enumerable[Rubydex::Definition] definitions, ?Integer? max_entries, ?extra_links: String?) -> String
+        def markdown_from_definitions(title, definitions, max_entries = nil, extra_links: nil)
+          categorized_markdown = categorized_markdown_from_definitions(title, definitions, max_entries)
 
           markdown = +(categorized_markdown[:title] || "")
           markdown << "\n\n#{extra_links}" if extra_links
@@ -168,7 +178,20 @@ module RubyLsp
 
         #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
         def constant_name(node)
-          RubyIndexer::Index.constant_name(node)
+          Common.constant_name(node)
+        end
+
+        class << self
+          #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
+          def constant_name(node)
+            case node
+            when Prism::ConstantPathNode, Prism::ConstantReadNode, Prism::ConstantPathTargetNode
+              node.full_name
+            end
+          rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+                 Prism::ConstantPathNode::MissingNodesInConstantPathError
+            nil
+          end
         end
 
         #: ((Prism::ModuleNode | Prism::ClassNode) node) -> String?
@@ -192,28 +215,6 @@ module RubyLsp
             current = current.parent
           end
         end
-
-        #: (RubyIndexer::Entry entry) -> Integer
-        def kind_for_entry(entry)
-          case entry
-          when RubyIndexer::Entry::Class
-            Constant::SymbolKind::CLASS
-          when RubyIndexer::Entry::Module
-            Constant::SymbolKind::NAMESPACE
-          when RubyIndexer::Entry::Constant, RubyIndexer::Entry::UnresolvedConstantAlias, RubyIndexer::Entry::ConstantAlias
-            Constant::SymbolKind::CONSTANT
-          when RubyIndexer::Entry::Method, RubyIndexer::Entry::UnresolvedMethodAlias, RubyIndexer::Entry::MethodAlias
-            entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
-          when RubyIndexer::Entry::Accessor
-            Constant::SymbolKind::PROPERTY
-          when RubyIndexer::Entry::InstanceVariable, RubyIndexer::Entry::ClassVariable
-            Constant::SymbolKind::FIELD
-          when RubyIndexer::Entry::GlobalVariable
-            Constant::SymbolKind::VARIABLE
-          else
-            Constant::SymbolKind::NULL
-          end
-        end
       end
     end
   end

data/lib/ruby_lsp/ruby_document.rb

@@ -4,22 +4,6 @@
 module RubyLsp
   #: [ParseResultType = Prism::ParseLexResult]
   class RubyDocument < Document
-    METHODS_THAT_CHANGE_DECLARATIONS = [
-      :private_constant,
-      :attr_reader,
-      :attr_writer,
-      :attr_accessor,
-      :alias_method,
-      :include,
-      :prepend,
-      :extend,
-      :public,
-      :protected,
-      :private,
-      :module_function,
-      :private_class_method,
-    ].freeze
-
     class << self
       #: (Prism::Node node, Integer char_position, code_units_cache: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache), ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
       def locate(node, char_position, code_units_cache:, node_types: [])
@@ -190,62 +174,5 @@ module RubyLsp
         node_types: node_types,
       )
     end
-
-    #: -> bool
-    def should_index?
-      # This method controls when we should index documents. If there's no recent edit and the document has just been
-      # opened, we need to index it
-      return true unless @last_edit
-
-      last_edit_may_change_declarations?
-    end
-
-    private
-
-    #: -> bool
-    def last_edit_may_change_declarations?
-      case @last_edit
-      when Delete
-        # Not optimized yet. It's not trivial to identify that a declaration has been removed since the source is no
-        # longer there and we don't remember the deleted text
-        true
-      when Insert, Replace
-        position_may_impact_declarations?(@last_edit.range[:start])
-      else
-        false
-      end
-    end
-
-    #: (Hash[Symbol, Integer] position) -> bool
-    def position_may_impact_declarations?(position)
-      node_context = locate_node(position)
-      node_at_edit = node_context.node
-
-      # Adjust to the parent when editing the constant of a class/module declaration
-      if node_at_edit.is_a?(Prism::ConstantReadNode) || node_at_edit.is_a?(Prism::ConstantPathNode)
-        node_at_edit = node_context.parent
-      end
-
-      case node_at_edit
-      when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode,
-          Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
-          Prism::ConstantPathAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantWriteNode,
-          Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::GlobalVariableAndWriteNode,
-          Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableTargetNode,
-          Prism::GlobalVariableWriteNode, Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableTargetNode, Prism::AliasMethodNode
-        true
-      when Prism::MultiWriteNode
-        [*node_at_edit.lefts, *node_at_edit.rest, *node_at_edit.rights].any? do |node|
-          node.is_a?(Prism::ConstantTargetNode) || node.is_a?(Prism::ConstantPathTargetNode)
-        end
-      when Prism::CallNode
-        receiver = node_at_edit.receiver
-        (!receiver || receiver.is_a?(Prism::SelfNode)) && METHODS_THAT_CHANGE_DECLARATIONS.include?(node_at_edit.name)
-      else
-        false
-      end
-    end
   end
 end