ruby-lsp 0.27.0.beta1 → 0.27.0.beta3

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"))
@@ -311,8 +325,6 @@ module RubyLsp
         ))
       end
 
-      process_indexing_configuration(options.dig(:initializationOptions, :indexing))
-
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
 
       global_state_notifications.each { |notification| send_message(notification) }
@@ -422,8 +434,11 @@ module RubyLsp
 
       if [:ruby, :rbs].include?(language_id)
         graph = @global_state.graph
-        graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s)
-        graph.resolve
+
+        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
 
@@ -482,39 +497,15 @@ module RubyLsp
         document,
         dispatcher,
       )
-
-      # The code lens listener requires the index to be populated, so the DeclarationListener must be inserted first in
-      # the dispatcher's state
-      code_lens = nil #: Requests::CodeLens?
-
-      if document.is_a?(RubyDocument) && document.should_index?
-        # Re-index the file as it is modified. This mode of indexing updates entries only. Require path trees are only
-        # updated on save
-        @global_state.synchronize do
-          send_log_message("Determined that document should be indexed: #{uri}")
-
-          @global_state.index.handle_change(uri) do |index|
-            index.delete(uri, skip_require_paths_tree: true)
-            RubyIndexer::DeclarationListener.new(index, dispatcher, parse_result, uri, collect_comments: true)
-            code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
-            dispatcher.dispatch(document.ast)
-          end
-        end
-      else
-        code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
-        dispatcher.dispatch(document.ast)
-      end
+      code_lens = Requests::CodeLens.new(@global_state, document, dispatcher)
+      dispatcher.dispatch(document.ast)
 
       # Store all responses retrieve in this round of visits in the cache and then return the response for the request
       # we actually received
       document.cache_set("textDocument/foldingRange", folding_range.perform)
       document.cache_set("textDocument/documentSymbol", document_symbol.perform)
       document.cache_set("textDocument/documentLink", document_link.perform)
-      document.cache_set(
-        "textDocument/codeLens",
-        code_lens #: as !nil
-          .perform,
-      )
+      document.cache_set("textDocument/codeLens", code_lens.perform)
       document.cache_set("textDocument/inlayHint", inlay_hint.perform)
 
       send_message(Result.new(id: message[:id], response: document.cache_get(message[:method])))
@@ -1021,21 +1012,6 @@ module RubyLsp
 
     #: (Hash[Symbol, untyped] message) -> void
     def workspace_did_change_watched_files(message)
-      # If indexing is not complete yet, delay processing did change watched file notifications. We need initial
-      # indexing to be in place so that we can handle file changes appropriately without risking duplicates. We also
-      # have to sleep before re-inserting the notification in the queue otherwise the worker can get stuck in its own
-      # loop of pushing and popping the same notification
-      unless @global_state.index.initial_indexing_completed
-        Thread.new do
-          sleep(2)
-          # We have to ensure that the queue is not closed yet, since nothing stops the user from saving a file and then
-          # immediately telling the LSP to shutdown
-          @incoming_queue << message unless @incoming_queue.closed?
-        end
-
-        return
-      end
-
       changes = message.dig(:params, :changes)
       # We allow add-ons to register for watching files and we have no restrictions for what they register for. If the
       # same pattern is registered more than once, the LSP will receive duplicate change notifications. Receiving them
@@ -1056,21 +1032,15 @@ module RubyLsp
           acc << path
         end
       end
-      graph.index_all(additions_and_changes)
-      graph.resolve
+      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
         uri = URI(change[:uri])
         file_path = uri.to_standardized_path
         next if file_path.nil? || File.directory?(file_path)
 
-        if file_path.end_with?(".rb")
-          handle_ruby_file_change(index, file_path, change[:type])
-          next
-        end
-
         file_name = File.basename(file_path)
 
         if file_name == ".rubocop.yml" || file_name == ".rubocop" || file_name == ".rubocop_todo.yml"
@@ -1089,33 +1059,6 @@ module RubyLsp
       end
     end
 
-    #: (RubyIndexer::Index index, String file_path, Integer change_type) -> void
-    def handle_ruby_file_change(index, file_path, change_type)
-      @global_state.synchronize do
-        load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
-        uri = URI::Generic.from_path(load_path_entry: load_path_entry, path: file_path)
-
-        case change_type
-        when Constant::FileChangeType::CREATED
-          content = File.read(file_path)
-          # If we receive a late created notification for a file that has already been claimed by the client, we want to
-          # handle change for that URI so that the require path tree is updated
-          @store.key?(uri) ? index.handle_change(uri, content) : index.index_single(uri, content)
-        when Constant::FileChangeType::CHANGED
-          content = File.read(file_path)
-          # We only handle changes on file watched notifications if the client is not the one managing this URI.
-          # Otherwise, these changes are handled when running the combined requests
-          index.handle_change(uri, content) unless @store.key?(uri)
-        when Constant::FileChangeType::DELETED
-          index.delete(uri)
-        end
-      rescue Errno::ENOENT
-        # If a file is created and then delete immediately afterwards, we will process the created notification before
-        # we receive the deleted one, but the file no longer exists. This may happen when running a test suite that
-        # creates and deletes files automatically.
-      end
-    end
-
     #: (URI::Generic uri) -> void
     def handle_rubocop_config_change(uri)
       return unless defined?(Requests::Support::RuboCopFormatter)
@@ -1195,7 +1138,7 @@ module RubyLsp
 
       response = Requests::PrepareTypeHierarchy.new(
         document,
-        @global_state.index,
+        @global_state,
         params[:position],
       ).perform
 
@@ -1205,7 +1148,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))
@@ -1254,56 +1197,16 @@ module RubyLsp
 
     #: -> void
     def perform_initial_indexing
+      # Index
       progress("indexing-progress", message: "Indexing workspace...")
-      @global_state.graph.index_workspace
+      benchmark("index_workspace") { @global_state.graph.index_workspace }
 
+      # Resolve
       progress("indexing-progress", message: "Resolving graph...")
-      @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: percentage)
-            true
-          rescue ClosedQueueError
-            # Since we run indexing on a separate thread, it's possible to kill the server before indexing is complete.
-            # In those cases, the message queue will be closed and raise a ClosedQueueError. By returning `false`, we
-            # tell the index to stop working immediately
-            false
-          end
-        rescue StandardError => error
-          message = "Error while indexing (see [troubleshooting steps]" \
-            "(https://shopify.github.io/ruby-lsp/troubleshooting#indexing)): #{error.message}"
-          send_message(Notification.window_show_message(message, type: Constant::MessageType::ERROR))
-        end
-
-        # Indexing produces a high number of short lived object allocations. That might lead to some fragmentation and
-        # an unnecessarily expanded heap. Compacting ensures that the heap is as small as possible and that future
-        # allocations and garbage collections are faster
-        GC.compact unless @test_mode
-
-        @global_state.synchronize do
-          # If we linearize ancestors while the index is not fully populated, we may end up caching incorrect results
-          # that were missing namespaces. After indexing is complete, we need to clear the ancestors cache and start
-          # again
-          @global_state.index.clear_ancestors
-
-          # The results for code lens depend on ancestor linearization, so we need to clear any previously computed
-          # responses
-          @store.each { |_uri, document| document.clear_cache("textDocument/codeLens") }
-        end
-
-        # Always end the progress notification even if indexing failed or else it never goes away and the user has no
-        # way of dismissing it
-        end_progress("indexing-progress")
+      benchmark("full_resolve") { @global_state.graph.resolve }
 
-        # Request a code lens refresh if we populated them before all test parent classes were indexed
-        if @global_state.client_capabilities.supports_code_lens_refresh
-          send_message(Request.new(id: @current_request_id, method: "workspace/codeLens/refresh", params: nil))
-        end
-      end
+      # End
+      end_progress("indexing-progress")
     end
 
     #: (String id, String title, ?percentage: Integer) -> void
@@ -1356,47 +1259,6 @@ module RubyLsp
       end
     end
 
-    #: (Hash[Symbol, untyped]? indexing_options) -> void
-    def process_indexing_configuration(indexing_options)
-      # Need to use the workspace URI, otherwise, this will fail for people working on a project that is a symlink.
-      index_path = File.join(@global_state.workspace_path, ".index.yml")
-
-      if File.exist?(index_path)
-        begin
-          @global_state.index.configuration.apply_config(YAML.parse_file(index_path).to_ruby)
-          send_message(
-            Notification.new(
-              method: "window/showMessage",
-              params: Interface::ShowMessageParams.new(
-                type: Constant::MessageType::WARNING,
-                message: "The .index.yml configuration file is deprecated. " \
-                  "Please use editor settings to configure the index",
-              ),
-            ),
-          )
-        rescue Psych::SyntaxError => e
-          message = "Syntax error while loading configuration: #{e.message}"
-          send_message(
-            Notification.new(
-              method: "window/showMessage",
-              params: Interface::ShowMessageParams.new(
-                type: Constant::MessageType::WARNING,
-                message: message,
-              ),
-            ),
-          )
-        end
-        return
-      end
-
-      configuration = @global_state.index.configuration
-      configuration.workspace_path = @global_state.workspace_path
-      return unless indexing_options
-
-      # The index expects snake case configurations, but VS Code standardizes on camel case settings
-      configuration.apply_config(indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase })
-    end
-
     #: (Hash[Symbol, untyped] message) -> void
     def window_show_message_request(message)
       result = message[:result]
@@ -1558,5 +1420,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/test_helper.rb

@@ -29,7 +29,6 @@ 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

data/lib/ruby_lsp/test_reporters/lsp_reporter.rb

@@ -5,7 +5,7 @@ require "English"
 require "json"
 require "socket"
 require "tmpdir"
-require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
+require_relative "../uri"
 
 module RubyLsp
   class LspReporter

data/lib/ruby_lsp/type_inferrer.rb

@@ -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
@@ -78,7 +78,7 @@ module RubyLsp
         # When the receiver is a constant reference, we have to try to resolve it to figure out the right
         # receiver. But since the invocation is directly on the constant, that's the singleton context of that
         # class/module
-        receiver_name = RubyIndexer::Index.constant_name(receiver)
+        receiver_name = Requests::Support::Common.constant_name(receiver)
         return unless receiver_name
 
         resolved_receiver = @graph.resolve_constant(receiver_name, node_context.nesting)
@@ -124,26 +124,104 @@ module RubyLsp
 
       declaration = @graph.resolve_constant(guessed_name, nesting)
       declaration ||= @graph.search(guessed_name).first
-      return unless declaration
+      return unless declaration.is_a?(Rubydex::Namespace)
 
       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("::")}::<#{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?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.27.0.beta1
+  version: 0.27.0.beta3
 platform: ruby
 authors:
 - Shopify
@@ -69,14 +69,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0.beta1
+        version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0.beta1
+        version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: An opinionated language server for Ruby
 email:
 - ruby@shopify.com
@@ -98,18 +104,6 @@ files:
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
 - lib/ruby-lsp.rb
-- lib/ruby_indexer/lib/ruby_indexer/configuration.rb
-- lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb
-- lib/ruby_indexer/lib/ruby_indexer/enhancement.rb
-- lib/ruby_indexer/lib/ruby_indexer/entry.rb
-- lib/ruby_indexer/lib/ruby_indexer/index.rb
-- lib/ruby_indexer/lib/ruby_indexer/location.rb
-- lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
-- lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
-- lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb
-- lib/ruby_indexer/lib/ruby_indexer/uri.rb
-- lib/ruby_indexer/lib/ruby_indexer/visibility_scope.rb
-- lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
 - lib/ruby_lsp/client_capabilities.rb
@@ -182,23 +176,23 @@ files:
 - lib/ruby_lsp/response_builders/signature_help.rb
 - lib/ruby_lsp/response_builders/test_collection.rb
 - lib/ruby_lsp/ruby_document.rb
+- lib/ruby_lsp/rubydex/declaration.rb
 - lib/ruby_lsp/rubydex/definition.rb
 - lib/ruby_lsp/rubydex/reference.rb
+- lib/ruby_lsp/rubydex/signature.rb
 - lib/ruby_lsp/scope.rb
 - lib/ruby_lsp/scripts/compose_bundle.rb
 - lib/ruby_lsp/scripts/compose_bundle_windows.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
-- lib/ruby_lsp/static_docs.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
 - lib/ruby_lsp/test_reporters/lsp_reporter.rb
 - lib/ruby_lsp/test_reporters/minitest_reporter.rb
 - lib/ruby_lsp/test_reporters/test_unit_reporter.rb
 - lib/ruby_lsp/type_inferrer.rb
+- lib/ruby_lsp/uri.rb
 - lib/ruby_lsp/utils.rb
-- static_docs/break.md
-- static_docs/yield.md
 homepage: https://github.com/Shopify/ruby-lsp
 licenses:
 - MIT