ruby-lsp 0.27.0.beta1 → 0.27.0.beta3

data/lib/ruby_lsp/requests/references.rb

@@ -9,126 +9,240 @@ module RubyLsp
     class References < Request
       include Support::Common
 
+      MAX_NUMBER_OF_METHOD_CANDIDATES_WITHOUT_RECEIVER = 30
+
       #: (GlobalState global_state, Store store, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
+        @graph = global_state.graph #: Rubydex::Graph
         @store = store
         @document = document
         @params = params
         @locations = [] #: Array[Interface::Location]
+        @char_position = 0 #: Integer
       end
 
       # @override
       #: -> Array[Interface::Location]
       def perform
-        position = @params[:position]
-        char_position, _ = @document.find_index_by_position(position)
+        include_declarations = @params.dig(:context, :includeDeclaration) || false
+        @char_position, _ = @document.find_index_by_position(@params[:position])
 
         node_context = RubyDocument.locate(
           @document.ast,
-          char_position,
+          @char_position,
           node_types: [
             Prism::ConstantReadNode,
             Prism::ConstantPathNode,
             Prism::ConstantPathTargetNode,
+            Prism::ConstantAndWriteNode,
+            Prism::ConstantOperatorWriteNode,
+            Prism::ConstantOrWriteNode,
+            Prism::ConstantTargetNode,
+            Prism::ConstantWriteNode,
             Prism::InstanceVariableAndWriteNode,
             Prism::InstanceVariableOperatorWriteNode,
             Prism::InstanceVariableOrWriteNode,
             Prism::InstanceVariableReadNode,
             Prism::InstanceVariableTargetNode,
             Prism::InstanceVariableWriteNode,
+            Prism::ClassVariableAndWriteNode,
+            Prism::ClassVariableOperatorWriteNode,
+            Prism::ClassVariableOrWriteNode,
+            Prism::ClassVariableReadNode,
+            Prism::ClassVariableTargetNode,
+            Prism::ClassVariableWriteNode,
+            Prism::GlobalVariableAndWriteNode,
+            Prism::GlobalVariableOperatorWriteNode,
+            Prism::GlobalVariableOrWriteNode,
+            Prism::GlobalVariableReadNode,
+            Prism::GlobalVariableTargetNode,
+            Prism::GlobalVariableWriteNode,
             Prism::CallNode,
+            Prism::CallAndWriteNode,
+            Prism::CallOperatorWriteNode,
+            Prism::CallOrWriteNode,
             Prism::DefNode,
           ],
           code_units_cache: @document.code_units_cache,
         )
         target = node_context.node
-        parent = node_context.parent
         return @locations if !target || target.is_a?(Prism::ProgramNode)
 
-        if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
-          target = determine_target(
-            target,
-            parent,
-            position,
-          )
+        case target
+        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
+          name = constant_name(target)
+          handle_constant_references(name, node_context, include_declarations) if name
+        when Prism::ConstantTargetNode
+          handle_constant_references(target.name.to_s, node_context, include_declarations)
+        when Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode,
+          Prism::ConstantWriteNode
+          if cursor_on_name?(target.name_loc)
+            handle_constant_references(target.name.to_s, node_context, include_declarations)
+          end
+        when Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode,
+          Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
+          handle_variable_references(target.name.to_s, node_context, include_declarations)
+        when Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableWriteNode,
+          Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableOrWriteNode, Prism::ClassVariableWriteNode
+          if cursor_on_name?(target.name_loc)
+            handle_variable_references(target.name.to_s, node_context, include_declarations)
+          end
+        when Prism::GlobalVariableReadNode, Prism::GlobalVariableTargetNode
+          handle_global_variable_references(target.name.to_s, include_declarations)
+        when Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableOrWriteNode, Prism::GlobalVariableWriteNode
+          if cursor_on_name?(target.name_loc)
+            handle_global_variable_references(target.name.to_s, include_declarations)
+          end
+        when Prism::CallNode
+          message_loc = target.message_loc
+          message = target.message
+          if message && message_loc && cursor_on_name?(message_loc)
+            resolve_method_references(message, node_context, include_declarations)
+          end
+        when Prism::CallAndWriteNode, Prism::CallOperatorWriteNode, Prism::CallOrWriteNode
+          message_loc = target.message_loc
+          if message_loc && cursor_on_name?(message_loc)
+            resolve_method_references(target.read_name.to_s, node_context, include_declarations)
+          end
+        when Prism::DefNode
+          handle_def_node_references(target, node_context, include_declarations) if cursor_on_name?(target.name_loc)
         end
 
-        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode,
+        @locations
+      end
 
-        reference_target = create_reference_target(target, node_context)
-        return @locations unless reference_target
+      private
 
-        Dir.glob(File.join(@global_state.workspace_path, "**/*.rb")).each do |path|
-          uri = URI::Generic.from_path(path: path)
-          # If the document is being managed by the client, then we should use whatever is present in the store instead
-          # of reading from disk
-          next if @store.key?(uri)
+      #: (String name, NodeContext node_context, bool include_declarations) -> void
+      def handle_constant_references(name, node_context, include_declarations)
+        declaration = @graph.resolve_constant(name, node_context.nesting)
+        return unless declaration
 
-          parse_result = Prism.parse_lex_file(path)
-          collect_references(reference_target, parse_result, uri)
-        rescue Errno::EISDIR, Errno::ENOENT
-          # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
+        collect_references(declaration.references, [declaration], include_declarations)
+      end
+
+      #: (String message, NodeContext node_context, bool include_declarations) -> void
+      def resolve_method_references(message, node_context, include_declarations)
+        receiver_type = @type_inferrer.infer_receiver_type(node_context)
+
+        declaration = if receiver_type
+          owner = @graph[receiver_type.name]
+          owner.find_member("#{message}()") if owner.is_a?(Rubydex::Namespace)
         end
 
-        @store.each do |_uri, document|
-          collect_references(reference_target, document.parse_result, document.uri)
+        declarations = if receiver_type.nil? || (receiver_type.is_a?(TypeInferrer::GuessedType) && declaration.nil?)
+          @graph.search("##{message}()").take(MAX_NUMBER_OF_METHOD_CANDIDATES_WITHOUT_RECEIVER)
+        elsif declaration
+          [declaration]
+        else
+          []
         end
+        return if declarations.empty?
 
-        @locations
+        collect_references(method_references_for(message, declarations), declarations, include_declarations)
       end
 
-      private
+      # Handles instance and class variable references. Resolves the receiver type from the node context to locate
+      # the owning namespace, then looks up the member through the ancestor chain via `find_member`.
+      #: (String name, NodeContext node_context, bool include_declarations) -> void
+      def handle_variable_references(name, node_context, include_declarations)
+        type = @type_inferrer.infer_receiver_type(node_context)
+        return unless type
 
-      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode) target_node, NodeContext node_context) -> RubyIndexer::ReferenceFinder::Target?
-      def create_reference_target(target_node, node_context)
-        case target_node
-        when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
-          name = RubyIndexer::Index.constant_name(target_node)
-          return unless name
+        owner = @graph[type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
+
+        declaration = owner.find_member(name)
+        return unless declaration
+
+        collect_references(declaration.references, [declaration], include_declarations)
+      end
+
+      # Handles global variable references. Globals are keyed by their full name (including `$`) in the graph, so we
+      # can look them up directly without needing to resolve a receiver type.
+      #: (String name, bool include_declarations) -> void
+      def handle_global_variable_references(name, include_declarations)
+        declaration = @graph[name]
+        return unless declaration
+
+        collect_references(declaration.references, [declaration], include_declarations)
+      end
+
+      #: (Prism::DefNode target, NodeContext node_context, bool include_declarations) -> void
+      def handle_def_node_references(target, node_context, include_declarations)
+        method_name = target.name.to_s
 
-          entries = @global_state.index.resolve(name, node_context.nesting)
-          return unless entries
+        owner_type = @type_inferrer.infer_receiver_type(node_context)
+        return unless owner_type
 
-          fully_qualified_name = entries.first #: as !nil
+        owner = @graph[owner_type.name]
+        return unless owner.is_a?(Rubydex::Namespace)
+
+        declaration = owner.find_member("#{method_name}()")
+        return unless declaration
+
+        collect_references(method_references_for(method_name, [declaration]), [declaration], include_declarations)
+      end
+
+      #: (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
-          RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
-        when
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode
-          receiver_type = @global_state.type_inferrer.infer_receiver_type(node_context)
-          return unless receiver_type
-
-          ancestors = @global_state.index.linearized_ancestors_of(receiver_type.name)
-          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s, ancestors)
-        when Prism::CallNode, Prism::DefNode
-          RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
+        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
 
-      #: (RubyIndexer::ReferenceFinder::Target target, Prism::LexResult parse_result, URI::Generic uri) -> void
-      def collect_references(target, parse_result, uri)
-        dispatcher = Prism::Dispatcher.new
-        finder = RubyIndexer::ReferenceFinder.new(
-          target,
-          @global_state.index,
-          dispatcher,
-          uri,
-          include_declarations: @params.dig(:context, :includeDeclaration) || true,
-        )
-        dispatcher.visit(parse_result.value.first)
+      #: (Enumerable[Rubydex::Reference] references, Array[Rubydex::Declaration] declarations, bool include_declarations) -> void
+      def collect_references(references, declarations, include_declarations)
+        references.each do |reference|
+          next if rubydex_internal_uri?(reference.location.uri)
 
-        finder.references.each do |reference|
-          @locations << Interface::Location.new(
-            uri: uri.to_s,
-            range: range_from_location(reference.location),
-          )
+          @locations << reference.to_lsp_location
         end
+
+        return unless include_declarations
+
+        declarations.each do |declaration|
+          declaration.definitions.each do |definition|
+            next if rubydex_internal_uri?(definition.location.uri)
+
+            @locations << definition.to_lsp_selection_location
+          end
+        end
+      end
+
+      #: (String uri) -> bool
+      def rubydex_internal_uri?(uri)
+        URI(uri).scheme == "rubydex"
+      end
+
+      # Write, operator-write, and call-with-message nodes cover more than just the identifier —
+      # they span the whole assignment or call expression. We only resolve references when the
+      # cursor is positioned directly on the name itself, not on operators, values, or arguments.
+      #: (Prism::Location name_loc) -> bool
+      def cursor_on_name?(name_loc)
+        start = name_loc.cached_start_code_units_offset(@document.code_units_cache)
+        finish = name_loc.cached_end_code_units_offset(@document.code_units_cache)
+        (start...finish).cover?(@char_position)
       end
     end
   end

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/request.rb

@@ -5,6 +5,8 @@ module RubyLsp
   module Requests
     # @abstract
     class Request
+      include Support::Common
+
       class InvalidFormatter < StandardError; end
 
       # @abstract
@@ -26,24 +28,6 @@ module RubyLsp
         end
       end
 
-      # Checks if a location covers a position
-      #: (Prism::Location location, untyped position) -> bool
-      def cover?(location, position)
-        start_covered =
-          location.start_line - 1 < position[:line] ||
-          (
-            location.start_line - 1 == position[:line] &&
-              location.start_column <= position[:character]
-          )
-        end_covered =
-          location.end_line - 1 > position[:line] ||
-          (
-            location.end_line - 1 == position[:line] &&
-              location.end_column >= position[:character]
-          )
-        start_covered && end_covered
-      end
-
       # Based on a constant node target, a constant path node parent and a position, this method will find the exact
       # portion of the constant path that matches the requested position, for higher precision in hover and
       # definition. For example:
@@ -62,27 +46,13 @@ module RubyLsp
         parent = target #: as Prism::ConstantPathNode
           .parent #: Prism::Node?
 
-        while parent && cover?(parent.location, position)
+        while parent && covers_position?(parent.location, position)
           target = parent
           parent = target.is_a?(Prism::ConstantPathNode) ? target.parent : nil
         end
 
         target
       end
-
-      # Checks if a given location covers the position requested
-      #: (Prism::Location? location, Hash[Symbol, untyped] position) -> bool
-      def covers_position?(location, position)
-        return false unless location
-
-        start_line = location.start_line - 1
-        end_line = location.end_line - 1
-        line = position[:line]
-        character = position[:character]
-
-        (start_line < line || (start_line == line && location.start_column <= character)) &&
-          (end_line > line || (end_line == line && location.end_column >= character))
-      end
     end
   end
 end

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(
@@ -34,6 +34,19 @@ module RubyLsp
           )
         end
 
+        #: (Prism::Location? location, Hash[Symbol, untyped] position) -> bool
+        def covers_position?(location, position)
+          return false unless location
+
+          start_line = location.start_line - 1
+          end_line = location.end_line - 1
+          line = position[:line]
+          character = position[:character]
+
+          (start_line < line || (start_line == line && location.start_column <= character)) &&
+            (end_line > line || (end_line == line && location.end_column >= character))
+        end
+
         #: (Prism::Node node, title: String, command_name: String, arguments: Array[untyped]?, data: Hash[untyped, untyped]?) -> Interface::CodeLens
         def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_node(node)
@@ -64,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```"
@@ -74,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
 
@@ -104,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
@@ -155,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?
@@ -179,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