ruby-lsp 0.26.9 → 0.27.0.beta2

data/lib/ruby_lsp/rubydex/definition.rb

@@ -0,0 +1,257 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  # @abstract
+  class Definition
+    #: () -> RubyLsp::Interface::LocationLink
+    def to_lsp_location_link
+      selection_range = to_lsp_selection_range
+
+      RubyLsp::Interface::LocationLink.new(
+        target_uri: location.uri,
+        target_range: selection_range,
+        target_selection_range: to_lsp_name_range || selection_range,
+      )
+    end
+
+    # @abstract
+    #: () -> Integer
+    def to_lsp_kind
+      raise RubyLsp::AbstractMethodInvokedError
+    end
+
+    # Direct ancestor references contributed by this definition (superclass, includes, prepends).
+    # Extends are intentionally excluded here because they extend the singleton class, not the
+    # instance-side ancestor chain. Definition subclasses that can't contribute ancestors return [].
+    #: () -> Array[Rubydex::ConstantReference]
+    def direct_supertype_references
+      []
+    end
+
+    #: (String name, ?detail: String?) -> RubyLsp::Interface::TypeHierarchyItem
+    def to_lsp_type_hierarchy_item(name, detail: nil)
+      range = to_lsp_selection_range
+
+      RubyLsp::Interface::TypeHierarchyItem.new(
+        name: name,
+        kind: to_lsp_kind,
+        uri: location.uri,
+        range: range,
+        selection_range: to_lsp_name_range || range,
+        detail: detail,
+        data: { fully_qualified_name: name },
+      )
+    end
+
+    #: (String name) -> RubyLsp::Interface::WorkspaceSymbol
+    def to_lsp_workspace_symbol(name)
+      # We use the namespace as the container name, but we also use the full name as the regular name. The reason we do
+      # this is to allow people to search for fully qualified names (e.g.: `Foo::Bar`). If we only included the short
+      # name `Bar`, then searching for `Foo::Bar` would not return any results
+      *container, _short_name = name.split("::")
+      container_name = container.join("::")
+
+      RubyLsp::Interface::WorkspaceSymbol.new(
+        name: name,
+        container_name: container_name,
+        kind: to_lsp_kind,
+        location: to_lsp_selection_location,
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Range
+    def to_lsp_selection_range
+      loc = location
+
+      RubyLsp::Interface::Range.new(
+        start: RubyLsp::Interface::Position.new(line: loc.start_line, character: loc.start_column),
+        end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Location
+    def to_lsp_selection_location
+      location = self.location
+
+      RubyLsp::Interface::Location.new(
+        uri: location.uri,
+        range: RubyLsp::Interface::Range.new(
+          start: RubyLsp::Interface::Position.new(line: location.start_line, character: location.start_column),
+          end: RubyLsp::Interface::Position.new(line: location.end_line, character: location.end_column),
+        ),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Range?
+    def to_lsp_name_range
+      loc = name_location
+      return unless loc
+
+      RubyLsp::Interface::Range.new(
+        start: RubyLsp::Interface::Position.new(line: loc.start_line, character: loc.start_column),
+        end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Location?
+    def to_lsp_name_location
+      location = name_location
+      return unless location
+
+      RubyLsp::Interface::Location.new(
+        uri: location.uri,
+        range: RubyLsp::Interface::Range.new(
+          start: RubyLsp::Interface::Position.new(line: location.start_line, character: location.start_column),
+          end: RubyLsp::Interface::Position.new(line: location.end_line, character: location.end_column),
+        ),
+      )
+    end
+  end
+
+  # Shared supertype aggregation for Rubydex definition types that carry namespace mixins
+  # (`ClassDefinition`, `ModuleDefinition`, `SingletonClassDefinition`). The including class is
+  # expected to provide `#mixins`, which every Rubydex namespace definition already does.
+  # @abstract
+  module NamespaceDefinition
+    # @abstract
+    #: () -> Array[Rubydex::Mixin]
+    def mixins
+      raise RubyLsp::AbstractMethodInvokedError
+    end
+
+    #: () -> Array[Rubydex::ConstantReference]
+    def direct_supertype_references
+      mixins.filter_map do |mixin|
+        mixin.constant_reference if mixin.is_a?(Include) || mixin.is_a?(Prepend)
+      end
+    end
+  end
+
+  class ClassDefinition
+    include NamespaceDefinition
+
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CLASS
+    end
+
+    # @override
+    #: () -> Array[Rubydex::ConstantReference]
+    def direct_supertype_references
+      refs = super
+      superclass_ref = superclass
+      refs << superclass_ref if superclass_ref
+      refs
+    end
+  end
+
+  class ModuleDefinition
+    include NamespaceDefinition
+
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::NAMESPACE
+    end
+  end
+
+  class SingletonClassDefinition
+    include NamespaceDefinition
+
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CLASS
+    end
+  end
+
+  class ConstantDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CONSTANT
+    end
+  end
+
+  class ConstantAliasDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CONSTANT
+    end
+  end
+
+  class MethodDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      name == "initialize()" ? RubyLsp::Constant::SymbolKind::CONSTRUCTOR : RubyLsp::Constant::SymbolKind::METHOD
+    end
+  end
+
+  class MethodAliasDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::METHOD
+    end
+  end
+
+  class AttrReaderDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::PROPERTY
+    end
+  end
+
+  class AttrWriterDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::PROPERTY
+    end
+  end
+
+  class AttrAccessorDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::PROPERTY
+    end
+  end
+
+  class InstanceVariableDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::FIELD
+    end
+  end
+
+  class ClassVariableDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::FIELD
+    end
+  end
+
+  class GlobalVariableDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::VARIABLE
+    end
+  end
+
+  class GlobalVariableAliasDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::VARIABLE
+    end
+  end
+end

data/lib/ruby_lsp/rubydex/reference.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  class Reference
+    #: () -> RubyLsp::Interface::Range
+    def to_lsp_range
+      loc = location
+
+      RubyLsp::Interface::Range.new(
+        start: RubyLsp::Interface::Position.new(line: loc.start_line, character: loc.start_column),
+        end: RubyLsp::Interface::Position.new(line: loc.end_line, character: loc.end_column),
+      )
+    end
+
+    #: () -> RubyLsp::Interface::Location
+    def to_lsp_location
+      RubyLsp::Interface::Location.new(uri: location.uri, range: to_lsp_range)
+    end
+  end
+end

data/lib/ruby_lsp/server.rb

@@ -3,7 +3,11 @@
 
 module RubyLsp
   class Server < BaseServer
-    NON_REPORTABLE_SETUP_ERRORS = [Bundler::GemNotFound, Bundler::GitError].freeze #: Array[singleton(StandardError)]
+    NON_REPORTABLE_SETUP_ERRORS = [
+      Bundler::GemNotFound,
+      Bundler::GitError,
+      Bundler::Dsl::DSLError,
+    ].freeze #: Array[singleton(StandardError)]
 
     # Only for testing
     #: GlobalState
@@ -120,6 +124,16 @@ module RubyLsp
         @global_state.synchronize { @cancelled_requests << message[:params][:id] }
       when nil
         process_response(message) if message[:result]
+      else
+        id = message[:id]
+
+        if id
+          send_message(Error.new(
+            id: id,
+            code: Constant::ErrorCodes::METHOD_NOT_FOUND,
+            message: "Method not found: #{message[:method]}",
+          ))
+        end
       end
     rescue DelegateRequestError
       send_message(Error.new(id: message[:id], code: DelegateRequestError::CODE, message: "DELEGATE_REQUEST"))
@@ -415,7 +429,19 @@ module RubyLsp
       params = message[:params]
       text_document = params[:textDocument]
 
-      @store.push_edits(uri: text_document[:uri], edits: params[:contentChanges], version: text_document[:version])
+      document = @store.get(text_document[:uri])
+      document.push_edits(params[:contentChanges], version: text_document[:version])
+
+      language_id = document.language_id
+
+      if [:ruby, :rbs].include?(language_id)
+        graph = @global_state.graph
+
+        benchmark("index_source") do
+          graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s)
+        end
+        benchmark("incremental_resolve") { graph.resolve }
+      end
     end
 
     #: (Hash[Symbol, untyped] message) -> void
@@ -1033,6 +1059,23 @@ module RubyLsp
       # is fine, but we shouldn't process the same file changes more than once
       changes.uniq!
 
+      graph = @global_state.graph
+
+      # Handle deletions and accumulate additions and changes for indexing
+      additions_and_changes = changes.each_with_object([]) do |change, acc|
+        if change[:type] == Constant::FileChangeType::DELETED
+          graph.delete_document(change[:uri])
+        else
+          path = URI(change[:uri]).to_standardized_path
+          next if path.nil?
+          next unless File.directory?(path) || [".rb", ".rbs"].include?(File.extname(path))
+
+          acc << path
+        end
+      end
+      benchmark("index_all") { graph.index_all(additions_and_changes) }
+      benchmark("incremental_resolve") { graph.resolve }
+
       index = @global_state.index
       changes.each do |change|
         # File change events include folders, but we're only interested in files
@@ -1169,7 +1212,7 @@ module RubyLsp
 
       response = Requests::PrepareTypeHierarchy.new(
         document,
-        @global_state.index,
+        @global_state,
         params[:position],
       ).perform
 
@@ -1179,7 +1222,7 @@ module RubyLsp
     #: (Hash[Symbol, untyped] message) -> void
     def type_hierarchy_supertypes(message)
       response = Requests::TypeHierarchySupertypes.new(
-        @global_state.index,
+        @global_state,
         message.dig(:params, :item),
       ).perform
       send_message(Result.new(id: message[:id], response: response))
@@ -1228,12 +1271,18 @@ module RubyLsp
 
     #: -> void
     def perform_initial_indexing
+      progress("indexing-progress", message: "Indexing workspace...")
+      benchmark("index_workspace") { @global_state.graph.index_workspace }
+
+      progress("indexing-progress", message: "Resolving graph...")
+      benchmark("full_resolve") { @global_state.graph.resolve }
+
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
       Thread.new do
         begin
           @global_state.index.index_all do |percentage|
-            progress("indexing-progress", percentage)
+            progress("indexing-progress", percentage: percentage)
             true
           rescue ClosedQueueError
             # Since we run indexing on a separate thread, it's possible to kill the server before indexing is complete.
@@ -1287,11 +1336,13 @@ module RubyLsp
       send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
     end
 
-    #: (String id, Integer percentage) -> void
-    def progress(id, percentage)
+    #: (String, ?message: String?, ?percentage: Integer?) -> void
+    def progress(id, message: nil, percentage: nil)
       return unless @global_state.client_capabilities.supports_progress
 
-      send_message(Notification.progress_report(id, percentage: percentage, message: "#{percentage}% completed"))
+      message ||= "#{percentage}% completed" if percentage
+
+      send_message(Notification.progress_report(id, percentage: percentage, message: message))
     end
 
     #: (String id) -> void
@@ -1524,5 +1575,28 @@ module RubyLsp
         response: code_lens,
       ))
     end
+
+    #: [T] (String) { () -> T } -> T
+    def benchmark(label, &block)
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      result = block.call
+      duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+
+      send_message(Notification.telemetry({
+        type: "data",
+        eventName: "ruby_lsp.response_time",
+        data: {
+          type: "histogram",
+          value: duration,
+          attributes: {
+            message: label,
+            lspVersion: RubyLsp::VERSION,
+            rubyVersion: RUBY_VERSION,
+          },
+        },
+      }))
+
+      result
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -53,12 +53,6 @@ module RubyLsp
       end
     end
 
-    #: (uri: URI::Generic, edits: Array[Hash[Symbol, untyped]], version: Integer) -> void
-    def push_edits(uri:, edits:, version:)
-      @state[uri.to_s] #: as !nil
-        .push_edits(edits, version: version)
-    end
-
     #: -> void
     def clear
       @state.clear

data/lib/ruby_lsp/test_helper.rb

@@ -30,6 +30,9 @@ module RubyLsp
         })
 
         server.global_state.index.index_single(uri, source)
+        graph = server.global_state.graph
+        graph.index_source(uri.to_s, source, "ruby")
+        graph.resolve
       end
 
       server.load_addons(include_project_addons: false) if load_addons

data/lib/ruby_lsp/type_inferrer.rb

@@ -5,9 +5,9 @@ module RubyLsp
   # A minimalistic type checker to try to resolve types that can be inferred without requiring a type system or
   # annotations
   class TypeInferrer
-    #: (RubyIndexer::Index index) -> void
-    def initialize(index)
-      @index = index
+    #: (Rubydex::Graph) -> void
+    def initialize(graph)
+      @graph = graph
     end
 
     #: (NodeContext node_context) -> Type?
@@ -19,7 +19,7 @@ module RubyLsp
         infer_receiver_for_call_node(node, node_context)
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
         Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
-        Prism::SuperNode, Prism::ForwardingSuperNode
+        Prism::SuperNode, Prism::ForwardingSuperNode, Prism::DefNode
         self_receiver_handling(node_context)
       when Prism::ClassVariableAndWriteNode, Prism::ClassVariableWriteNode, Prism::ClassVariableOperatorWriteNode,
         Prism::ClassVariableOrWriteNode, Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode
@@ -81,14 +81,13 @@ module RubyLsp
         receiver_name = RubyIndexer::Index.constant_name(receiver)
         return unless receiver_name
 
-        resolved_receiver = @index.resolve(receiver_name, node_context.nesting)
-        name = resolved_receiver&.first&.name
-        return unless name
+        resolved_receiver = @graph.resolve_constant(receiver_name, node_context.nesting)
+        return unless resolved_receiver
 
-        *parts, last = name.split("::")
-        return Type.new("#{last}::<Class:#{last}>") if parts.empty?
+        *parts, last = resolved_receiver.name.split("::")
+        return Type.new("#{last}::<#{last}>") if parts.empty?
 
-        Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
+        Type.new("#{parts.join("::")}::#{last}::<#{last}>")
       when Prism::CallNode
         raw_receiver = receiver.message
 
@@ -96,12 +95,14 @@ module RubyLsp
           # When invoking `new`, we recursively infer the type of the receiver to get the class type its being invoked
           # on and then return the attached version of that type, since it's being instantiated.
           type = infer_receiver_for_call_node(receiver, node_context)
-
           return unless type
 
           # If the method `new` was overridden, then we cannot assume that it will return a new instance of the class
-          new_method = @index.resolve_method("new", type.name)&.first
-          return if new_method && new_method.owner&.name != "Class"
+          declaration = @graph[type.name] #: as Rubydex::Namespace?
+          return unless declaration
+
+          new_method = declaration.find_member("new()")
+          return if new_method && new_method.owner.name != "Class"
 
           type.attached
         elsif raw_receiver
@@ -121,45 +122,124 @@ module RubyLsp
         .map(&:capitalize)
         .join
 
-      entries = @index.resolve(guessed_name, nesting) || @index.first_unqualified_const(guessed_name)
-      name = entries&.first&.name
-      return unless name
+      declaration = @graph.resolve_constant(guessed_name, nesting)
+      declaration ||= @graph.search(guessed_name).first
+      return unless declaration
 
-      GuessedType.new(name)
+      GuessedType.new(declaration.name)
     end
 
-    #: (NodeContext node_context) -> Type
+    #: (NodeContext node_context) -> Type?
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
       # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
       # inherits from Object
       return Type.new("Object") if nesting.empty?
-      return Type.new(node_context.fully_qualified_name) if node_context.surrounding_method
+
+      surrounding_method = node_context.surrounding_method
+
+      if surrounding_method
+        receiver_name = surrounding_method.receiver
+
+        case receiver_name
+        when "self"
+          # `def self.foo` — self is the singleton of the enclosing class/module
+          return resolve_singleton_type_from_nesting(nesting)
+        when "none"
+          # Instance method — self is an instance of the enclosing class/module
+          return resolve_type_from_nesting(nesting)
+        when nil
+          # Dynamic receiver that we cannot handle
+          return
+        else
+          # Explicit constant receiver (e.g. `def Bar.baz`) — self is that constant's singleton class
+          resolved = resolve_receiver_singleton_type(receiver_name, nesting)
+          return resolved if resolved
+
+          return resolve_type_from_nesting(nesting)
+        end
+      end
 
       # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-      # context.
-      #
-      # If the class/module definition is using compact style (e.g.: `class Foo::Bar`), then we need to split the name
-      # into its individual parts to build the correct singleton name
-      parts = nesting.flat_map { |part| part.split("::") }
-      Type.new("#{parts.join("::")}::<Class:#{parts.last}>")
+      # context. Resolve through the graph to get the correct fully qualified name
+      resolve_singleton_type_from_nesting(nesting)
+    end
+
+    # Resolves the fully qualified name of the innermost constant from the nesting and returns it as a type.
+    # For instance methods, the nesting won't have singleton markers, so the result is an instance type.
+    # For `def self.` methods, the nesting includes a singleton marker, which is preserved in the result.
+    #: (Array[String] nesting) -> Type
+    def resolve_type_from_nesting(nesting)
+      resolved_name = resolve_nesting_fully_qualified_name(nesting)
+      Type.new(resolved_name)
+    end
+
+    # Resolves the nesting and returns a singleton type (appends `::<Last>`)
+    #: (Array[String] nesting) -> Type
+    def resolve_singleton_type_from_nesting(nesting)
+      resolved_name = resolve_nesting_fully_qualified_name(nesting)
+      last_part = resolved_name.split("::").last #: as !nil
+      Type.new("#{resolved_name}::<#{last_part}>")
+    end
+
+    # Resolves the innermost constant in the nesting through the graph, handling compact-path definitions
+    # like `class Bar::Baz` inside a different module where the lexical nesting doesn't reflect the true
+    # constant hierarchy. Falls back to lexical joining if resolution fails.
+    #: (Array[String] nesting) -> String
+    def resolve_nesting_fully_qualified_name(nesting)
+      nesting_parts = nesting.dup
+      trailing_singletons = [] #: Array[String]
+
+      nesting_parts.reverse_each do |part|
+        break unless part.start_with?("<")
+
+        popped = nesting_parts.pop #: as !nil
+        trailing_singletons.unshift(popped)
+      end
+
+      if nesting_parts.any?
+        resolved = @graph.resolve_constant(
+          nesting_parts.last, #: as !nil
+          nesting_parts[0...-1], #: as !nil
+        )
+
+        if resolved
+          parts = resolved.name.split("::") + trailing_singletons
+          return parts.join("::")
+        end
+      end
+
+      # Fallback to lexical joining if resolution fails
+      nesting.flat_map { |part| part.split("::") }.join("::")
+    end
+
+    #: (String, Array[String]) -> Type?
+    def resolve_receiver_singleton_type(receiver_name, nesting)
+      receiver_declaration = @graph.resolve_constant(receiver_name, nesting)
+      return unless receiver_declaration.is_a?(Rubydex::Namespace)
+
+      singleton = receiver_declaration.singleton_class
+      return unless singleton
+
+      Type.new(singleton.name)
     end
 
     #: (NodeContext node_context) -> Type?
     def infer_receiver_for_class_variables(node_context)
       nesting_parts = node_context.nesting.dup
-
       return Type.new("Object") if nesting_parts.empty?
 
       nesting_parts.reverse_each do |part|
-        break unless part.include?("<Class:")
+        break unless part.start_with?("<")
 
         nesting_parts.pop
       end
 
-      receiver_name = nesting_parts.join("::")
-      resolved_receiver = @index.resolve(receiver_name, node_context.nesting)&.first
-      return unless resolved_receiver&.name
+      resolved_receiver = @graph.resolve_constant(
+        nesting_parts.last, #: as !nil
+        nesting_parts[0...-1], #: as !nil
+      )
+      return unless resolved_receiver
 
       Type.new(resolved_receiver.name)
     end
@@ -174,7 +254,7 @@ module RubyLsp
         @name = name
       end
 
-      # Returns the attached version of this type by removing the `<Class:...>` part from its name
+      # Returns the attached version of this type by removing the `<...>` part from its name
       #: -> Type
       def attached
         Type.new(