ruby-lsp 0.17.6 → 0.17.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7299237468ae17d80028a1454903f58b1be4ff34428a6c8a538530b5caad54d1
-  data.tar.gz: 26351e5be1671219a9b3624076b2f50fb68c5838303fe1a021eecb39c4e3e9f1
+  metadata.gz: e3a8a120b4cf3045cdeec98d2fb417ffdd300947b6426788d827346c43812ffc
+  data.tar.gz: b43a823e71fca99a9cf79b3a6ce19e7a0ec86e499b943aecae1666788859d055
 SHA512:
-  metadata.gz: 54cc76a3506a268398cfc51645a70300e2d14bda5b39c12274863270f70ed666b33bfebdf50dac8e013410e8ddba5645f4f435863af795d268710e0ccf9d8814
-  data.tar.gz: 95e52a4aa6f68785495f7435fe54cc395c062809ad3754703f808c68d2599bc34a619578bbb8453cb54de88a8312ac49eff8dd2e72a82bc04554c7b659c477cd
+  metadata.gz: 9662d88d3f37b4fd7b744a69f38f2a20cd4bf00291f63968578e50bef3400916870efdcf58b6e81dd78a6829c4f8a7dd174e6d212ddc3a265420b29eaa2b6d8a
+  data.tar.gz: b788ef9185e02a732cd2dccef6273d8dd3fb471ebb8c2300b3ac78cc48d3952eee378a777cc4cf4ceb927590fff7bcdfc57c95f0924b21e589eb850ec9128641

data/README.md

@@ -78,7 +78,12 @@ default gems, except for
 - Gems that only appear under the `:development` group
 - All Ruby files under `test/**/*.rb`
 
-By creating a `.index.yml` file, these configurations can be overridden and tuned. Note that indexing dependent behavior, such as definition, hover, completion or workspace symbol will be impacted by the configurations placed here.
+This behaviour can be overridden and tuned. Learn how to configure it [for VS Code](vscode/README.md#Indexing-Configuration) or [for other editors](EDITORS.md#Indexing-Configuration).
+
+Note that indexing-dependent behavior, such as definition, hover, completion or workspace symbol will be impacted by
+the configuration changes.
+
+The older approach of using a `.index.yml` file has been deprecated and will be removed in a future release.
 
 ```yaml
 # Exclude files based on a given pattern. Often used to exclude test files or fixtures

data/VERSION

@@ -1 +1 @@
-0.17.6
+0.17.8

data/exe/ruby-lsp

@@ -36,6 +36,10 @@ parser = OptionParser.new do |opts|
     options[:experimental] = true
   end
 
+  opts.on("--doctor", "Run troubleshooting steps") do
+    options[:doctor] = true
+  end
+
   opts.on("-h", "--help", "Print this help") do
     puts opts.help
     puts
@@ -107,4 +111,25 @@ if options[:time_index]
   return
 end
 
+if options[:doctor]
+  if File.exist?(".index.yml")
+    begin
+      config = YAML.parse_file(".index.yml").to_ruby
+    rescue => e
+      abort("Error parsing config: #{e.message}")
+    end
+    RubyIndexer.configuration.apply_config(config)
+  end
+
+  index = RubyIndexer::Index.new
+
+  puts "Globbing for indexable files"
+
+  RubyIndexer.configuration.indexables.each do |indexable|
+    puts "indexing: #{indexable.full_path}"
+    index.index_single(indexable)
+  end
+  return
+end
+
 RubyLsp::Server.new.start

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -71,7 +71,7 @@ module RubyIndexer
 
       superclass = node.superclass
 
-      nesting = name.start_with?("::") ? [name.delete_prefix("::")] : @stack + [name.delete_prefix("::")]
+      nesting = actual_nesting(name)
 
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -119,8 +119,7 @@ module RubyIndexer
 
       comments = collect_comments(node)
 
-      nesting = name.start_with?("::") ? [name.delete_prefix("::")] : @stack + [name.delete_prefix("::")]
-      entry = Entry::Module.new(nesting, @file_path, node.location, constant_path.location, comments)
+      entry = Entry::Module.new(actual_nesting(name), @file_path, node.location, constant_path.location, comments)
 
       @owner_stack << entry
       @index.add(entry)
@@ -709,5 +708,19 @@ module RubyIndexer
         :"(#{names_with_commas})"
       end
     end
+
+    sig { params(name: String).returns(T::Array[String]) }
+    def actual_nesting(name)
+      nesting = @stack + [name]
+      corrected_nesting = []
+
+      nesting.reverse_each do |name|
+        corrected_nesting.prepend(name.delete_prefix("::"))
+
+        break if name.start_with?("::")
+      end
+
+      corrected_nesting
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -331,14 +331,17 @@ module RubyIndexer
       params(
         method_name: String,
         receiver_name: String,
+        inherited_only: T::Boolean,
       ).returns(T.nilable(T::Array[T.any(Entry::Member, Entry::MethodAlias)]))
     end
-    def resolve_method(method_name, receiver_name)
+    def resolve_method(method_name, receiver_name, inherited_only: false)
       method_entries = self[method_name]
       return unless method_entries
 
       ancestors = linearized_ancestors_of(receiver_name.delete_prefix("::"))
       ancestors.each do |ancestor|
+        next if inherited_only && ancestor == receiver_name
+
         found = method_entries.filter_map do |entry|
           case entry
           when Entry::Member, Entry::MethodAlias

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -546,5 +546,43 @@ module RubyIndexer
       assert_equal(7, name_location.start_column)
       assert_equal(10, name_location.end_column)
     end
+
+    def test_indexing_namespaces_inside_top_level_references
+      index(<<~RUBY)
+        module ::Foo
+          class Bar
+          end
+        end
+      RUBY
+
+      # We want to explicitly verify that we didn't introduce the leading `::` by accident, but `Index#[]` deletes the
+      # prefix when we use `refute_entry`
+      entries = @index.instance_variable_get(:@entries)
+      refute(entries.key?("::Foo"))
+      refute(entries.key?("::Foo::Bar"))
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:0-0:3-3")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:1-2:2-5")
+    end
+
+    def test_indexing_namespaces_inside_nested_top_level_references
+      index(<<~RUBY)
+        class Baz
+          module ::Foo
+            class Bar
+            end
+
+            class ::Qux
+            end
+          end
+        end
+      RUBY
+
+      refute_entry("Baz::Foo")
+      refute_entry("Baz::Foo::Bar")
+      assert_entry("Baz", Entry::Class, "/fake/path/foo.rb:0-0:8-3")
+      assert_entry("Foo", Entry::Module, "/fake/path/foo.rb:1-2:7-5")
+      assert_entry("Foo::Bar", Entry::Class, "/fake/path/foo.rb:2-4:3-7")
+      assert_entry("Qux", Entry::Class, "/fake/path/foo.rb:5-4:6-7")
+    end
   end
 end

data/lib/ruby_indexer/test/index_test.rb

@@ -285,6 +285,43 @@ module RubyIndexer
       assert_includes(second_entry.comments, "Hello from second `bar`")
     end
 
+    def test_resolve_method_inherited_only
+      index(<<~RUBY)
+        class Bar
+          def baz; end
+        end
+
+        class Foo < Bar
+          def baz; end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Foo", inherited_only: true).first)
+
+      assert_equal("Bar", T.must(entry.owner).name)
+    end
+
+    def test_resolve_method_inherited_only_for_prepended_module
+      index(<<~RUBY)
+        module Bar
+          def baz
+            super
+          end
+        end
+
+        class Foo
+          prepend Bar
+
+          def baz; end
+        end
+      RUBY
+
+      # This test is just to document the fact that we don't yet support resolving inherited methods for modules that
+      # are prepended. The only way to support this is to find all namespaces that have the module a subtype, so that we
+      # can show the results for everywhere the module has been prepended.
+      assert_nil(@index.resolve_method("baz", "Bar", inherited_only: true))
+    end
+
     def test_prefix_search_for_methods
       index(<<~RUBY)
         module Foo

data/lib/ruby_lsp/base_server.rb

@@ -53,7 +53,7 @@ module RubyLsp
 
               # We don't want to try to parse documents on text synchronization notifications
               @store.get(parsed_uri).parse unless method.start_with?("textDocument/did")
-            rescue Errno::ENOENT
+            rescue Store::NonExistingDocumentError
               # If we receive a request for a file that no longer exists, we don't want to fail
             end
           end

data/lib/ruby_lsp/document.rb

@@ -127,8 +127,18 @@ module RubyLsp
       parent = T.let(nil, T.nilable(Prism::Node))
       nesting_nodes = T.let(
         [],
-        T::Array[T.any(Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode)],
+        T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
       )
+
+      nesting_nodes << node if node.is_a?(Prism::ProgramNode)
       call_node = T.let(nil, T.nilable(Prism::CallNode))
 
       until queue.empty?
@@ -158,11 +168,8 @@ module RubyLsp
         # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
         # target when it is a constant
         case candidate
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting_nodes << candidate
-        when Prism::SingletonClassNode
-          nesting_nodes << candidate
-        when Prism::DefNode
+        when Prism::ClassNode, Prism::ModuleNode, Prism::SingletonClassNode, Prism::DefNode, Prism::BlockNode,
+          Prism::LambdaNode
           nesting_nodes << candidate
         end
 
@@ -203,24 +210,7 @@ module RubyLsp
         end
       end
 
-      nesting = []
-      surrounding_method = T.let(nil, T.nilable(String))
-
-      nesting_nodes.each do |node|
-        case node
-        when Prism::ClassNode, Prism::ModuleNode
-          nesting << node.constant_path.slice
-        when Prism::SingletonClassNode
-          nesting << "<Class:#{nesting.last}>"
-        when Prism::DefNode
-          surrounding_method = node.name.to_s
-          next unless node.receiver.is_a?(Prism::SelfNode)
-
-          nesting << "<Class:#{nesting.last}>"
-        end
-      end
-
-      NodeContext.new(closest, parent, nesting, call_node, surrounding_method)
+      NodeContext.new(closest, parent, nesting_nodes, call_node)
     end
 
     sig { returns(T::Boolean) }

data/lib/ruby_lsp/global_state.rb

@@ -69,7 +69,7 @@ module RubyLsp
       @formatter = detect_formatter(direct_dependencies, all_dependencies) if @formatter == "auto"
 
       specified_linters = options.dig(:initializationOptions, :linters)
-      @linters = specified_linters || detect_linters(direct_dependencies)
+      @linters = specified_linters || detect_linters(direct_dependencies, all_dependencies)
       @test_library = detect_test_library(direct_dependencies)
       @has_type_checker = detect_typechecker(direct_dependencies)
 
@@ -127,10 +127,14 @@ module RubyLsp
 
     # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a
     # single linter. To have multiple linters running, the user must configure them manually
-    sig { params(dependencies: T::Array[String]).returns(T::Array[String]) }
-    def detect_linters(dependencies)
+    sig { params(dependencies: T::Array[String], all_dependencies: T::Array[String]).returns(T::Array[String]) }
+    def detect_linters(dependencies, all_dependencies)
       linters = []
-      linters << "rubocop" if dependencies.any?(/^rubocop/)
+
+      if dependencies.any?(/^rubocop/) || (all_dependencies.include?("rubocop") && dot_rubocop_yml_present)
+        linters << "rubocop"
+      end
+
       linters
     end
 

data/lib/ruby_lsp/listeners/completion.rb

@@ -7,6 +7,50 @@ module RubyLsp
       extend T::Sig
       include Requests::Support::Common
 
+      KEYWORDS = [
+        "alias",
+        "and",
+        "begin",
+        "BEGIN",
+        "break",
+        "case",
+        "class",
+        "def",
+        "defined?",
+        "do",
+        "else",
+        "elsif",
+        "end",
+        "END",
+        "ensure",
+        "false",
+        "for",
+        "if",
+        "in",
+        "module",
+        "next",
+        "nil",
+        "not",
+        "or",
+        "redo",
+        "rescue",
+        "retry",
+        "return",
+        "self",
+        "super",
+        "then",
+        "true",
+        "undef",
+        "unless",
+        "until",
+        "when",
+        "while",
+        "yield",
+        "__ENCODING__",
+        "__FILE__",
+        "__LINE__",
+      ].freeze
+
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
@@ -277,6 +321,12 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode, name: String).void }
       def complete_methods(node, name)
+        # If the node has a receiver, then we don't need to provide local nor keyword completions
+        if !@global_state.has_type_checker && !node.receiver
+          add_local_completions(node, name)
+          add_keyword_completions(node, name)
+        end
+
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
 
@@ -322,6 +372,44 @@ module RubyLsp
         # We have not indexed this namespace, so we can't provide any completions
       end
 
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_local_completions(node, name)
+        range = range_from_location(T.must(node.message_loc))
+
+        @node_context.locals_for_scope.each do |local|
+          local_name = local.to_s
+          next unless local_name.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: local_name,
+            filter_text: local_name,
+            text_edit: Interface::TextEdit.new(range: range, new_text: local_name),
+            kind: Constant::CompletionItemKind::VARIABLE,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
+      end
+
+      sig { params(node: Prism::CallNode, name: String).void }
+      def add_keyword_completions(node, name)
+        range = range_from_location(T.must(node.message_loc))
+
+        KEYWORDS.each do |keyword|
+          next unless keyword.start_with?(name)
+
+          @response_builder << Interface::CompletionItem.new(
+            label: keyword,
+            text_edit: Interface::TextEdit.new(range: range, new_text: keyword),
+            kind: Constant::CompletionItemKind::KEYWORD,
+            data: {
+              skip_resolve: true,
+            },
+          )
+        end
+      end
+
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
         # We should use the content location as we only replace the content and not the delimiters of the string

data/lib/ruby_lsp/listeners/definition.rb

@@ -46,6 +46,8 @@ module RubyLsp
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
           :on_string_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
@@ -133,8 +135,30 @@ module RubyLsp
         handle_instance_variable_definition(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_definition
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_definition
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_definition
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_definition(
+          surrounding_method,
+          @type_inferrer.infer_receiver_type(@node_context),
+          inherited_only: true,
+        )
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
         type = @type_inferrer.infer_receiver_type(@node_context)
@@ -158,10 +182,10 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(message: String, receiver_type: T.nilable(String)).void }
-      def handle_method_definition(message, receiver_type)
+      sig { params(message: String, receiver_type: T.nilable(String), inherited_only: T::Boolean).void }
+      def handle_method_definition(message, receiver_type, inherited_only: false)
         methods = if receiver_type
-          @index.resolve_method(message, receiver_type)
+          @index.resolve_method(message, receiver_type, inherited_only: inherited_only)
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to
           # But we don't want to provide too many candidates, as it can be overwhelming

data/lib/ruby_lsp/listeners/hover.rb

@@ -21,6 +21,8 @@ module RubyLsp
           Prism::InstanceVariableWriteNode,
           Prism::SymbolNode,
           Prism::StringNode,
+          Prism::SuperNode,
+          Prism::ForwardingSuperNode,
         ],
         T::Array[T.class_of(Prism::Node)],
       )
@@ -64,6 +66,8 @@ module RubyLsp
           :on_instance_variable_operator_write_node_enter,
           :on_instance_variable_or_write_node_enter,
           :on_instance_variable_target_node_enter,
+          :on_super_node_enter,
+          :on_forwarding_super_node_enter,
         )
       end
 
@@ -106,17 +110,7 @@ module RubyLsp
         message = node.message
         return unless message
 
-        type = @type_inferrer.infer_receiver_type(@node_context)
-        return unless type
-
-        methods = @index.resolve_method(message, type)
-        return unless methods
-
-        title = "#{message}#{T.must(methods.first).decorated_parameters}"
-
-        categorized_markdown_from_index_entries(title, methods).each do |category, content|
-          @response_builder.push(content, category: category)
-        end
+        handle_method_hover(message)
       end
 
       sig { params(node: Prism::InstanceVariableReadNode).void }
@@ -149,8 +143,41 @@ module RubyLsp
         handle_instance_variable_hover(node.name.to_s)
       end
 
+      sig { params(node: Prism::SuperNode).void }
+      def on_super_node_enter(node)
+        handle_super_node_hover
+      end
+
+      sig { params(node: Prism::ForwardingSuperNode).void }
+      def on_forwarding_super_node_enter(node)
+        handle_super_node_hover
+      end
+
       private
 
+      sig { void }
+      def handle_super_node_hover
+        surrounding_method = @node_context.surrounding_method
+        return unless surrounding_method
+
+        handle_method_hover(surrounding_method, inherited_only: true)
+      end
+
+      sig { params(message: String, inherited_only: T::Boolean).void }
+      def handle_method_hover(message, inherited_only: false)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type, inherited_only: inherited_only)
+        return unless methods
+
+        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+
+        categorized_markdown_from_index_entries(title, methods).each do |category, content|
+          @response_builder.push(content, category: category)
+        end
+      end
+
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
         type = @type_inferrer.infer_receiver_type(@node_context)

data/lib/ruby_lsp/node_context.rb

@@ -23,22 +23,82 @@ module RubyLsp
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
-        nesting: T::Array[String],
+        nesting_nodes: T::Array[T.any(
+          Prism::ClassNode,
+          Prism::ModuleNode,
+          Prism::SingletonClassNode,
+          Prism::DefNode,
+          Prism::BlockNode,
+          Prism::LambdaNode,
+          Prism::ProgramNode,
+        )],
         call_node: T.nilable(Prism::CallNode),
-        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node, surrounding_method)
+    def initialize(node, parent, nesting_nodes, call_node)
       @node = node
       @parent = parent
-      @nesting = nesting
+      @nesting_nodes = nesting_nodes
       @call_node = call_node
-      @surrounding_method = surrounding_method
+
+      nesting, surrounding_method = handle_nesting_nodes(nesting_nodes)
+      @nesting = T.let(nesting, T::Array[String])
+      @surrounding_method = T.let(surrounding_method, T.nilable(String))
     end
 
     sig { returns(String) }
     def fully_qualified_name
       @fully_qualified_name ||= T.let(@nesting.join("::"), T.nilable(String))
     end
+
+    sig { returns(T::Array[Symbol]) }
+    def locals_for_scope
+      locals = []
+
+      @nesting_nodes.each do |node|
+        if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode) || node.is_a?(Prism::SingletonClassNode) ||
+            node.is_a?(Prism::DefNode)
+          locals.clear
+        end
+
+        locals.concat(node.locals)
+      end
+
+      locals
+    end
+
+    private
+
+    sig do
+      params(nodes: T::Array[T.any(
+        Prism::ClassNode,
+        Prism::ModuleNode,
+        Prism::SingletonClassNode,
+        Prism::DefNode,
+        Prism::BlockNode,
+        Prism::LambdaNode,
+        Prism::ProgramNode,
+      )]).returns([T::Array[String], T.nilable(String)])
+    end
+    def handle_nesting_nodes(nodes)
+      nesting = []
+      surrounding_method = T.let(nil, T.nilable(String))
+
+      @nesting_nodes.each do |node|
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          nesting << node.constant_path.slice
+        when Prism::SingletonClassNode
+          nesting << "<Class:#{nesting.last}>"
+        when Prism::DefNode
+          surrounding_method = node.name.to_s
+          next unless node.receiver.is_a?(Prism::SelfNode)
+
+          nesting << "<Class:#{nesting.last}>"
+        end
+      end
+
+      [nesting, surrounding_method]
+    end
   end
 end

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -38,6 +38,8 @@ module RubyLsp
 
       sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def perform
+        return @item if @item.dig(:data, :skip_resolve)
+
         # Based on the spec https://microsoft.github.io/language-server-protocol/specification#textDocument_completion,
         # a completion resolve request must always return the original completion item without modifying ANY fields
         # other than detail and documentation (NOT labelDetails). If we modify anything, the completion behaviour might

data/lib/ruby_lsp/requests/definition.rb

@@ -62,6 +62,8 @@ module RubyLsp
             Prism::InstanceVariableWriteNode,
             Prism::SymbolNode,
             Prism::StringNode,
+            Prism::SuperNode,
+            Prism::ForwardingSuperNode,
           ],
         )
 

data/lib/ruby_lsp/server.rb

@@ -98,16 +98,27 @@ module RubyLsp
     rescue StandardError, LoadError => e
       # If an error occurred in a request, we have to return an error response or else the editor will hang
       if message[:id]
-        send_message(Error.new(
-          id: message[:id],
-          code: Constant::ErrorCodes::INTERNAL_ERROR,
-          message: e.full_message,
-          data: {
-            errorClass: e.class.name,
-            errorMessage: e.message,
-            backtrace: e.backtrace&.join("\n"),
-          },
-        ))
+        # If a document is deleted before we are able to process all of its enqueued requests, we will try to read it
+        # from disk and it raise this error. This is expected, so we don't include the `data` attribute to avoid
+        # reporting these to our telemetry
+        if e.is_a?(Store::NonExistingDocumentError)
+          send_message(Error.new(
+            id: message[:id],
+            code: Constant::ErrorCodes::INVALID_PARAMS,
+            message: e.full_message,
+          ))
+        else
+          send_message(Error.new(
+            id: message[:id],
+            code: Constant::ErrorCodes::INTERNAL_ERROR,
+            message: e.full_message,
+            data: {
+              errorClass: e.class.name,
+              errorMessage: e.message,
+              backtrace: e.backtrace&.join("\n"),
+            },
+          ))
+        end
       end
 
       $stderr.puts("Error processing #{message[:method]}: #{e.full_message}")
@@ -243,6 +254,8 @@ module RubyLsp
         )
       end
 
+      process_indexing_configuration(options.dig(:initializationOptions, :indexing))
+
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
     end
 
@@ -251,28 +264,6 @@ module RubyLsp
       load_addons
       RubyVM::YJIT.enable if defined?(RubyVM::YJIT.enable)
 
-      indexing_config = {}
-
-      # 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
-          indexing_config = YAML.parse_file(index_path).to_ruby
-        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
-      end
-
       if defined?(Requests::Support::RuboCopFormatter)
         @global_state.register_formatter("rubocop", Requests::Support::RuboCopFormatter.new)
       end
@@ -280,7 +271,7 @@ module RubyLsp
         @global_state.register_formatter("syntax_tree", Requests::Support::SyntaxTreeFormatter.new)
       end
 
-      perform_initial_indexing(indexing_config)
+      perform_initial_indexing
       check_formatter_is_available
     end
 
@@ -766,12 +757,10 @@ module RubyLsp
       Addon.addons.each(&:deactivate)
     end
 
-    sig { params(config_hash: T::Hash[String, T.untyped]).void }
-    def perform_initial_indexing(config_hash)
+    sig { void }
+    def perform_initial_indexing
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
-      RubyIndexer.configuration.apply_config(config_hash)
-
       Thread.new do
         begin
           RubyIndexer::RBSIndexer.new(@global_state.index).index_ruby_core
@@ -872,5 +861,46 @@ module RubyLsp
         )
       end
     end
+
+    sig { params(indexing_options: T.nilable(T::Hash[Symbol, T.untyped])).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
+          RubyIndexer.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
+
+      return unless indexing_options
+
+      # The index expects snake case configurations, but VS Code standardizes on camel case settings
+      RubyIndexer.configuration.apply_config(
+        indexing_options.transform_keys { |key| key.to_s.gsub(/([A-Z])/, "_\\1").downcase },
+      )
+    end
   end
 end

data/lib/ruby_lsp/store.rb

@@ -5,6 +5,8 @@ module RubyLsp
   class Store
     extend T::Sig
 
+    class NonExistingDocumentError < StandardError; end
+
     sig { returns(T::Boolean) }
     attr_accessor :supports_progress
 
@@ -45,6 +47,8 @@ module RubyLsp
       end
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
       T.must(@state[uri.to_s])
+    rescue Errno::ENOENT
+      raise NonExistingDocumentError, uri.to_s
     end
 
     sig do

data/lib/ruby_lsp/type_inferrer.rb

@@ -20,16 +20,9 @@ module RubyLsp
       when Prism::CallNode
         infer_receiver_for_call_node(node, node_context)
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
-        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode
-        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 "Object" if nesting.empty?
-
-        fully_qualified_name = node_context.fully_qualified_name
-        return fully_qualified_name if node_context.surrounding_method
-
-        "#{fully_qualified_name}::<Class:#{nesting.last}>"
+        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode,
+        Prism::SuperNode, Prism::ForwardingSuperNode
+        self_receiver_handling(node_context)
       end
     end
 
@@ -41,15 +34,7 @@ module RubyLsp
 
       case receiver
       when Prism::SelfNode, nil
-        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 "Object" if nesting.empty?
-        return node_context.fully_qualified_name if node_context.surrounding_method
-
-        # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
-        # context
-        "#{nesting.join("::")}::<Class:#{nesting.last}>"
+        self_receiver_handling(node_context)
       when Prism::ConstantPathNode, Prism::ConstantReadNode
         # 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
@@ -68,6 +53,19 @@ module RubyLsp
       end
     end
 
+    sig { params(node_context: NodeContext).returns(String) }
+    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 "Object" if nesting.empty?
+      return node_context.fully_qualified_name if node_context.surrounding_method
+
+      # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+      # context
+      "#{nesting.join("::")}::<Class:#{nesting.last}>"
+    end
+
     sig do
       params(
         node: T.any(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.6
+  version: 0.17.8
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-10 00:00:00.000000000 Z
+date: 2024-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -84,7 +84,6 @@ email:
 executables:
 - ruby-lsp
 - ruby-lsp-check
-- ruby-lsp-doctor
 extensions: []
 extra_rdoc_files: []
 files:
@@ -93,7 +92,6 @@ files:
 - VERSION
 - exe/ruby-lsp
 - exe/ruby-lsp-check
-- exe/ruby-lsp-doctor
 - lib/core_ext/uri.rb
 - lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb
 - lib/rubocop/cop/ruby_lsp/use_register_with_handler_method.rb
@@ -206,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
+rubygems_version: 3.5.15
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby

data/exe/ruby-lsp-doctor

@@ -1,23 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-require "ruby_lsp/internal"
-
-if File.exist?(".index.yml")
-  begin
-    config = YAML.parse_file(".index.yml").to_ruby
-  rescue => e
-    abort("Error parsing config: #{e.message}")
-  end
-  RubyIndexer.configuration.apply_config(config)
-end
-
-index = RubyIndexer::Index.new
-
-puts "Globbing for indexable files"
-
-RubyIndexer.configuration.indexables.each do |indexable|
-  puts "indexing: #{indexable.full_path}"
-  index.index_single(indexable)
-end