ruby-lsp 0.27.0.beta2 → 0.27.0.beta4

data/lib/ruby_lsp/rubydex/declaration.rb

@@ -2,12 +2,13 @@
 # frozen_string_literal: true
 
 module Rubydex
+  # @abstract
   class Declaration
     # Detail text shown on a `TypeHierarchyItem` for this declaration. Hints at multiplicity
     # when the declaration spans more than one re-open; otherwise falls back to the primary
     # definition's file name so users can quickly see where the type comes from.
     #
-    #: () -> String?
+    #: -> String?
     def lsp_type_hierarchy_detail
       defs = definitions
       count = defs.count
@@ -20,13 +21,20 @@ module Rubydex
       path = uri.full_path
       path ? File.basename(path) : uri.to_s
     end
+
+    # @abstract
+    #: -> Integer
+    def to_lsp_completion_kind
+      raise RubyLsp::AbstractMethodInvokedError
+    end
   end
 
+  # @abstract
   class Namespace
     # Resolved, deduplicated direct supertypes across every re-open of this declaration.
     # Aggregates each definition's own `superclass`/`include`/`prepend` references and drops
     # unresolved ones. Order is stable (first-seen across definitions).
-    #: () -> Array[Rubydex::Namespace]
+    #: -> Array[Rubydex::Namespace]
     def direct_supertypes
       seen = {} #: Hash[String, Rubydex::Namespace]
 
@@ -45,4 +53,122 @@ module Rubydex
       seen.values
     end
   end
+
+  class Class
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CLASS
+    end
+  end
+
+  class Module
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::MODULE
+    end
+  end
+
+  class SingletonClass
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CLASS
+    end
+  end
+
+  class Todo
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CLASS
+    end
+  end
+
+  class Constant
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CONSTANT
+    end
+  end
+
+  class ConstantAlias
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::CONSTANT
+    end
+  end
+
+  class Method
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::METHOD
+    end
+
+    # All signatures collected across every definition (re-opens, RBS overloads, alias targets) of this method.
+    #: () -> Array[Rubydex::Signature]
+    def signatures
+      definitions.flat_map do |defn|
+        case defn
+        when Rubydex::MethodDefinition, Rubydex::MethodAliasDefinition
+          defn.signatures
+        else
+          []
+        end
+      end
+    end
+
+    # Decorated parameter list of the first signature, e.g. `(a, b = <default>, &block)`. Returns `()` when there are
+    # no signatures (e.g. an unresolved alias).
+    #: () -> String
+    def decorated_parameters
+      first = signatures.first
+      return "()" unless first
+
+      "(#{first.format})"
+    end
+
+    # Suffix line that hints at additional overloads beyond the first signature, matching the legacy index entry
+    # rendering used in hover.
+    #: () -> String
+    def formatted_signatures
+      count = signatures.size
+      case count
+      when 0, 1
+        ""
+      when 2
+        "\n(+1 overload)"
+      else
+        "\n(+#{count - 1} overloads)"
+      end
+    end
+  end
+
+  class InstanceVariable
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::FIELD
+    end
+  end
+
+  class ClassVariable
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::FIELD
+    end
+  end
+
+  class GlobalVariable
+    # @override
+    #: -> Integer
+    def to_lsp_completion_kind
+      RubyLsp::Constant::CompletionItemKind::VARIABLE
+    end
+  end
 end

data/lib/ruby_lsp/rubydex/definition.rb

@@ -183,6 +183,14 @@ module Rubydex
     end
   end
 
+  class ConstantVisibilityDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::CONSTANT
+    end
+  end
+
   class MethodDefinition
     # @override
     #: () -> Integer
@@ -199,6 +207,14 @@ module Rubydex
     end
   end
 
+  class MethodVisibilityDefinition
+    # @override
+    #: () -> Integer
+    def to_lsp_kind
+      RubyLsp::Constant::SymbolKind::METHOD
+    end
+  end
+
   class AttrReaderDefinition
     # @override
     #: () -> Integer

data/lib/ruby_lsp/rubydex/signature.rb

@@ -0,0 +1,107 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rubydex
+  class Signature
+    # Returns a string with the decorated names of the parameters of this signature, e.g.
+    # `(a, b = <default>, *c, d, e:, f: <default>, **g, &h)`.
+    #: () -> String
+    def format
+      parameters.map { |param| decorated_name(param) }.join(", ")
+    end
+
+    # Returns `true` if the given call node arguments array matches this signature. The matching is intentionally lenient
+    # because this method is used to detect which overload should be displayed in signature help while the user is still
+    # typing the call. We prefer returning `true` for situations that cannot be analyzed statically (e.g. presence of
+    # splats, keyword splats, forwarding) and accept missing arguments since the user may not be done typing yet.
+    #: (Array[Prism::Node] arguments) -> bool
+    def matches?(arguments)
+      min_pos = 0
+      max_pos = 0 #: (Integer | Float)
+      names = []
+      has_forward = false #: bool
+      has_keyword_rest = false #: bool
+
+      parameters.each do |param|
+        case param
+        when PositionalParameter, PostParameter
+          min_pos += 1
+          max_pos += 1
+        when OptionalPositionalParameter
+          max_pos += 1
+        when RestPositionalParameter
+          max_pos = Float::INFINITY
+        when ForwardParameter
+          max_pos = Float::INFINITY
+          has_forward = true
+        when KeywordParameter, OptionalKeywordParameter
+          names << param.name
+        when RestKeywordParameter
+          has_keyword_rest = true
+        end
+      end
+
+      keyword_hash_nodes, positional_args = arguments.partition { |arg| arg.is_a?(Prism::KeywordHashNode) }
+      keyword_args = keyword_hash_nodes.first #: as Prism::KeywordHashNode?
+        &.elements
+      forwarding_arguments, positionals = positional_args.partition do |arg|
+        arg.is_a?(Prism::ForwardingArgumentsNode)
+      end
+
+      return true if has_forward && min_pos == 0
+
+      # If the only argument passed is a forwarding argument, then anything will match
+      (positionals.empty? && forwarding_arguments.any?) ||
+        (
+          positional_arguments_match?(positionals, forwarding_arguments, keyword_args, min_pos, max_pos) &&
+          (has_forward || has_keyword_rest || keyword_arguments_match?(keyword_args, names))
+        )
+    end
+
+    private
+
+    #: (Parameter) -> String
+    def decorated_name(param)
+      case param
+      when OptionalPositionalParameter
+        "#{param.name} = <default>"
+      when RestPositionalParameter
+        "*#{param.name}"
+      when KeywordParameter
+        "#{param.name}:"
+      when OptionalKeywordParameter
+        "#{param.name}: <default>"
+      when RestKeywordParameter
+        "**#{param.name}"
+      when BlockParameter
+        "&#{param.name}"
+      else
+        param.name.to_s
+      end
+    end
+
+    #: (Array[Prism::Node] positional_args, Array[Prism::Node] forwarding_arguments, Array[Prism::Node]? keyword_args, Integer min_pos, (Integer | Float) max_pos) -> bool
+    def positional_arguments_match?(positional_args, forwarding_arguments, keyword_args, min_pos, max_pos)
+      (min_pos > 0 && positional_args.any? { |arg| arg.is_a?(Prism::SplatNode) }) ||
+        (min_pos - positional_args.length > 0 && keyword_args&.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }) ||
+        (min_pos - positional_args.length > 0 && forwarding_arguments.any?) ||
+        (min_pos > 0 && positional_args.length <= max_pos) ||
+        (min_pos == 0 && positional_args.empty?)
+    end
+
+    #: (Array[Prism::Node]? args, Array[Symbol] names) -> bool
+    def keyword_arguments_match?(args, names)
+      return true unless args
+      return true if args.any? { |arg| arg.is_a?(Prism::AssocSplatNode) }
+
+      arg_names = args.filter_map do |arg|
+        next unless arg.is_a?(Prism::AssocNode)
+
+        key = arg.key
+        key.value&.to_sym if key.is_a?(Prism::SymbolNode)
+      end
+
+      (arg_names - names).empty?
+    end
+  end
+end

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -5,7 +5,7 @@ def compose(raw_initialize, **options)
   require_relative "../setup_bundler"
   require "json"
   require "uri"
-  require_relative "../../ruby_indexer/lib/ruby_indexer/uri"
+  require_relative "../uri"
 
   initialize_request = JSON.parse(raw_initialize, symbolize_names: true)
   workspace_uri = initialize_request.dig(:params, :workspaceFolders, 0, :uri)

data/lib/ruby_lsp/server.rb

@@ -325,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) }
@@ -373,6 +371,7 @@ module RubyLsp
         end
       end
 
+      load_rubydex_config
       perform_initial_indexing
       check_formatter_is_available
       update_server if @global_state.enabled_feature?(:launcher)
@@ -437,10 +436,15 @@ module RubyLsp
       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
+        begin_progress("incremental-indexing-progress", "Ruby LSP: indexing files")
+
+        progress("incremental-indexing-progress", message: "Indexing file...")
+        benchmark("index_source") { graph.index_source(text_document[:uri].to_s, document.source, language_id.to_s) }
+
+        progress("incremental-indexing-progress", message: "Resolving graph...")
         benchmark("incremental_resolve") { graph.resolve }
+
+        end_progress("incremental-indexing-progress")
       end
     end
 
@@ -499,39 +503,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])))
@@ -1038,21 +1018,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
@@ -1073,21 +1038,23 @@ module RubyLsp
           acc << path
         end
       end
+
+      begin_progress("incremental-indexing-progress", "Ruby LSP: indexing files")
+
+      progress("incremental-indexing-progress", message: "Indexing files...")
       benchmark("index_all") { graph.index_all(additions_and_changes) }
+
+      progress("incremental-indexing-progress", message: "Resolving graph...")
       benchmark("incremental_resolve") { graph.resolve }
 
-      index = @global_state.index
+      end_progress("incremental-indexing-progress")
+
       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"
@@ -1106,33 +1073,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)
@@ -1271,60 +1211,20 @@ module RubyLsp
 
     #: -> void
     def perform_initial_indexing
+      # Index
       progress("indexing-progress", message: "Indexing workspace...")
       benchmark("index_workspace") { @global_state.graph.index_workspace }
 
+      # Resolve
       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: 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")
-
-        # 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
-    def begin_progress(id, title, percentage: 0)
+    #: (String id, String title, ?percentage: Integer?, ?message: String?) -> void
+    def begin_progress(id, title, percentage: nil, message: nil)
       return unless @global_state.client_capabilities.supports_progress
 
       send_message(Request.new(
@@ -1333,7 +1233,10 @@ module RubyLsp
         params: Interface::WorkDoneProgressCreateParams.new(token: id),
       ))
 
-      send_message(Notification.progress_begin(id, title, percentage: percentage, message: "#{percentage}% completed"))
+      # Omitting the percentage tells the client to show indefinite progress. Only fabricate a "% completed" message
+      # when a caller reports incremental percentages and didn't provide an explicit message
+      message ||= "#{percentage}% completed" if percentage
+      send_message(Notification.progress_begin(id, title, percentage: percentage, message: message))
     end
 
     #: (String, ?message: String?, ?percentage: Integer?) -> void
@@ -1373,47 +1276,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]
@@ -1598,5 +1460,15 @@ module RubyLsp
 
       result
     end
+
+    #: () -> void
+    def load_rubydex_config
+      @global_state.graph.load_config
+    rescue Rubydex::ConfigError => e
+      send_message(Notification.window_show_message(
+        "Error loading rubydex config: #{e.message}",
+        type: Constant::MessageType::ERROR,
+      ))
+    end
   end
 end

data/lib/ruby_lsp/setup_bundler.rb

@@ -445,7 +445,7 @@ module RubyLsp
       requirement = Gem::Requirement.new(@bundler_version.to_s)
       return if Gem::Specification.any? { |s| s.name == "bundler" && requirement =~ s.version }
 
-      Gem.install("bundler", @bundler_version.to_s)
+      Gem.install("bundler", @bundler_version.to_s, env_shebang: true)
     end
 
     #: -> bool

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