ruby-lsp 0.12.3 → 0.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b053184e8e593901a5344dfd3d34d20962fd2ed773900e00112be751008dae7d
-  data.tar.gz: '087be2ed7ace3fdb9eed751215a806deab096c6a5aa415d170eceaa45286c4d9'
+  metadata.gz: 2cb6c373890a19400025a75be13971ff5e5e33772bd74a178784a035ba94c168
+  data.tar.gz: d52ad65673ea9f1dfde13cfa6beec0f8c860a75b7f08453238597d584227b56f
 SHA512:
-  metadata.gz: e29d0633e023d4d3ce3efe5347479d9e2c16b1cbf02638e29b8f617158c08d7aae84ae4ad1f5898f6bd34033e841070d8cd2ffe8d67180ad4c554f3d5f80b564
-  data.tar.gz: 7a74cc5acca390661a196e21760f6c82e00478a02539c4c5cc2d17089948287762886c8a169d2384b59aa7e3324dda08fc3fa52a1aa6112951a2a8bc6b9253ab
+  metadata.gz: ba64686636c26776797fc6e7e70156f4c7f304dbe27e98c73c2a60a7255ae7260159838d68c0364e98bc58d26c404118ad9e3d1cfe13766a2221cbc4d2ac6a7c
+  data.tar.gz: fcf587173133668739ddc639d913ce34877cc1c0d3451b2ddc49254940ef8ba49815cae57dce2c6de423d3d3fb0db1059f1b8d2d19cd9d1de3af72fb26819759

data/README.md

@@ -52,6 +52,7 @@ The Ruby LSP provides an addon system that allows other gems to enhance the base
 features. This is the mechanism that powers addons like
 
 - [Ruby LSP Rails](https://github.com/Shopify/ruby-lsp-rails)
+- [Ruby LSP RSpec](https://github.com/st0012/ruby-lsp-rspec)
 
 For instructions on how to create addons, see the [addons documentation](ADDONS.md).
 

data/VERSION

@@ -1 +1 @@
-0.12.3
+0.12.5

data/exe/ruby-lsp-doctor

@@ -10,6 +10,6 @@ RubyIndexer.configuration.indexables.each do |indexable|
   puts "indexing: #{indexable.full_path}"
   content = File.read(indexable.full_path)
   result = Prism.parse(content)
-  visitor = RubyIndexer::IndexVisitor.new(index, result, indexable.full_path)
-  result.value.accept(visitor)
+  collector = RubyIndexer::Collector.new(index, result, indexable.full_path)
+  collector.collect(result.value)
 end

data/lib/ruby_indexer/lib/ruby_indexer/{visitor.rb → collector.rb}

@@ -2,9 +2,11 @@
 # frozen_string_literal: true
 
 module RubyIndexer
-  class IndexVisitor < Prism::Visitor
+  class Collector
     extend T::Sig
 
+    LEAVE_EVENT = T.let(Object.new.freeze, Object)
+
     sig { params(index: Index, parse_result: Prism::ParseResult, file_path: String).void }
     def initialize(index, parse_result, file_path)
       @index = index
@@ -16,22 +18,63 @@ module RubyIndexer
         end,
         T::Hash[Integer, Prism::Comment],
       )
+      @queue = T.let([], T::Array[Object])
+      @current_owner = T.let(nil, T.nilable(Entry::Namespace))
 
       super()
     end
 
-    sig { override.params(node: Prism::ClassNode).void }
-    def visit_class_node(node)
-      add_class_entry(node)
+    sig { params(node: Prism::Node).void }
+    def collect(node)
+      @queue = [node]
+
+      until @queue.empty?
+        node_or_event = @queue.shift
+
+        case node_or_event
+        when Prism::ProgramNode
+          @queue << node_or_event.statements
+        when Prism::StatementsNode
+          T.unsafe(@queue).prepend(*node_or_event.body)
+        when Prism::ClassNode
+          add_class_entry(node_or_event)
+        when Prism::ModuleNode
+          add_module_entry(node_or_event)
+        when Prism::MultiWriteNode
+          handle_multi_write_node(node_or_event)
+        when Prism::ConstantPathWriteNode
+          handle_constant_path_write_node(node_or_event)
+        when Prism::ConstantPathOrWriteNode
+          handle_constant_path_or_write_node(node_or_event)
+        when Prism::ConstantPathOperatorWriteNode
+          handle_constant_path_operator_write_node(node_or_event)
+        when Prism::ConstantPathAndWriteNode
+          handle_constant_path_and_write_node(node_or_event)
+        when Prism::ConstantWriteNode
+          handle_constant_write_node(node_or_event)
+        when Prism::ConstantOrWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::ConstantAndWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::ConstantOperatorWriteNode
+          name = fully_qualify_name(node_or_event.name.to_s)
+          add_constant(node_or_event, name)
+        when Prism::CallNode
+          handle_call_node(node_or_event)
+        when Prism::DefNode
+          handle_def_node(node_or_event)
+        when LEAVE_EVENT
+          @stack.pop
+        end
+      end
     end
 
-    sig { override.params(node: Prism::ModuleNode).void }
-    def visit_module_node(node)
-      add_module_entry(node)
-    end
+    private
 
-    sig { override.params(node: Prism::MultiWriteNode).void }
-    def visit_multi_write_node(node)
+    sig { params(node: Prism::MultiWriteNode).void }
+    def handle_multi_write_node(node)
       value = node.value
       values = value.is_a?(Prism::ArrayNode) && value.opening_loc ? value.elements : []
 
@@ -50,8 +93,8 @@ module RubyIndexer
       end
     end
 
-    sig { override.params(node: Prism::ConstantPathWriteNode).void }
-    def visit_constant_path_write_node(node)
+    sig { params(node: Prism::ConstantPathWriteNode).void }
+    def handle_constant_path_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -60,8 +103,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathOrWriteNode).void }
-    def visit_constant_path_or_write_node(node)
+    sig { params(node: Prism::ConstantPathOrWriteNode).void }
+    def handle_constant_path_or_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -70,8 +113,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathOperatorWriteNode).void }
-    def visit_constant_path_operator_write_node(node)
+    sig { params(node: Prism::ConstantPathOperatorWriteNode).void }
+    def handle_constant_path_operator_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -80,8 +123,8 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantPathAndWriteNode).void }
-    def visit_constant_path_and_write_node(node)
+    sig { params(node: Prism::ConstantPathAndWriteNode).void }
+    def handle_constant_path_and_write_node(node)
       # ignore variable constants like `var::FOO` or `self.class::FOO`
       target = node.target
       return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
@@ -90,50 +133,44 @@ module RubyIndexer
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantWriteNode).void }
-    def visit_constant_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::ConstantOrWriteNode).void }
-    def visit_constant_or_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::ConstantAndWriteNode).void }
-    def visit_constant_and_write_node(node)
+    sig { params(node: Prism::ConstantWriteNode).void }
+    def handle_constant_write_node(node)
       name = fully_qualify_name(node.name.to_s)
       add_constant(node, name)
     end
 
-    sig { override.params(node: Prism::ConstantOperatorWriteNode).void }
-    def visit_constant_operator_write_node(node)
-      name = fully_qualify_name(node.name.to_s)
-      add_constant(node, name)
-    end
-
-    sig { override.params(node: Prism::CallNode).void }
-    def visit_call_node(node)
+    sig { params(node: Prism::CallNode).void }
+    def handle_call_node(node)
       message = node.message
       handle_private_constant(node) if message == "private_constant"
     end
 
-    sig { override.params(node: Prism::DefNode).void }
-    def visit_def_node(node)
+    sig { params(node: Prism::DefNode).void }
+    def handle_def_node(node)
       method_name = node.name.to_s
       comments = collect_comments(node)
       case node.receiver
       when nil
-        @index << Entry::InstanceMethod.new(method_name, @file_path, node.location, comments, node.parameters)
+        @index << Entry::InstanceMethod.new(
+          method_name,
+          @file_path,
+          node.location,
+          comments,
+          node.parameters,
+          @current_owner,
+        )
       when Prism::SelfNode
-        @index << Entry::SingletonMethod.new(method_name, @file_path, node.location, comments, node.parameters)
+        @index << Entry::SingletonMethod.new(
+          method_name,
+          @file_path,
+          node.location,
+          comments,
+          node.parameters,
+          @current_owner,
+        )
       end
     end
 
-    private
-
     sig { params(node: Prism::CallNode).void }
     def handle_private_constant(node)
       arguments = node.arguments&.arguments
@@ -189,12 +226,12 @@ module RubyIndexer
 
         # If the right hand side is another constant assignment, we need to visit it because that constant has to be
         # indexed too
-        visit(value)
+        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.name.to_s, @stack.dup, name, @file_path, node.location, comments)
       when Prism::ConstantPathWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode,
         Prism::ConstantPathAndWriteNode
 
-        visit(value)
+        @queue.prepend(value)
         Entry::UnresolvedAlias.new(value.target.slice, @stack.dup, name, @file_path, node.location, comments)
       else
         Entry::Constant.new(name, @file_path, node.location, comments)
@@ -204,20 +241,26 @@ module RubyIndexer
     sig { params(node: Prism::ModuleNode).void }
     def add_module_entry(node)
       name = node.constant_path.location.slice
-      return visit_child_nodes(node) unless /^[A-Z:]/.match?(name)
+      unless /^[A-Z:]/.match?(name)
+        @queue << node.body
+        return
+      end
 
       comments = collect_comments(node)
-
-      @index << Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @current_owner = Entry::Module.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @index << @current_owner
       @stack << name
-      visit_child_nodes(node)
-      @stack.pop
+      @queue.prepend(node.body, LEAVE_EVENT)
     end
 
     sig { params(node: Prism::ClassNode).void }
     def add_class_entry(node)
       name = node.constant_path.location.slice
-      return visit_child_nodes(node) unless /^[A-Z:]/.match?(name)
+
+      unless /^[A-Z:]/.match?(name)
+        @queue << node.body
+        return
+      end
 
       comments = collect_comments(node)
 
@@ -227,10 +270,16 @@ module RubyIndexer
         superclass.slice
       end
 
-      @index << Entry::Class.new(fully_qualify_name(name), @file_path, node.location, comments, parent_class)
+      @current_owner = Entry::Class.new(
+        fully_qualify_name(name),
+        @file_path,
+        node.location,
+        comments,
+        parent_class,
+      )
+      @index << @current_owner
       @stack << name
-      visit(node.body)
-      @stack.pop
+      @queue.prepend(node.body, LEAVE_EVENT)
     end
 
     sig { params(node: Prism::Node).returns(T::Array[String]) }
@@ -249,7 +298,7 @@ module RubyIndexer
 
         comment_content.delete_prefix!("#")
         comment_content.delete_prefix!(" ")
-        comments.unshift(comment_content)
+        comments.prepend(comment_content)
       end
 
       comments

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -71,8 +71,13 @@ module RubyIndexer
 
         Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB).map! do |path|
           # All entries for the same pattern match the same $LOAD_PATH entry. Since searching the $LOAD_PATH for every
-          # entry is expensive, we memoize it for the entire pattern
-          load_path_entry ||= $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+          # entry is expensive, we memoize it until we find a path that doesn't belong to that $LOAD_PATH. This happens
+          # on repositories that define multiple gems, like Rails. All frameworks are defined inside the Dir.pwd, but
+          # each one of them belongs to a different $LOAD_PATH entry
+          if load_path_entry.nil? || !path.start_with?(load_path_entry)
+            load_path_entry = $LOAD_PATH.find { |load_path| path.start_with?(load_path) }
+          end
+
           IndexablePath.new(load_path_entry, path)
         end
       end
@@ -144,7 +149,7 @@ module RubyIndexer
         # just ignore if they're missing
       end
 
-      indexables.uniq!
+      indexables.uniq!(&:full_path)
       indexables
     end
 

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -101,6 +101,9 @@ module RubyIndexer
       sig { returns(T::Array[Parameter]) }
       attr_reader :parameters
 
+      sig { returns(T.nilable(Entry::Namespace)) }
+      attr_reader :owner
+
       sig do
         params(
           name: String,
@@ -108,11 +111,13 @@ module RubyIndexer
           location: Prism::Location,
           comments: T::Array[String],
           parameters_node: T.nilable(Prism::ParametersNode),
+          owner: T.nilable(Entry::Namespace),
         ).void
       end
-      def initialize(name, file_path, location, comments, parameters_node)
+      def initialize(name, file_path, location, comments, parameters_node, owner) # rubocop:disable Metrics/ParameterLists
         super(name, file_path, location, comments)
         @parameters = T.let(list_params(parameters_node), T::Array[Parameter])
+        @owner = owner
       end
 
       private

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

@@ -93,8 +93,14 @@ module RubyIndexer
     #   [#<Entry::Class name="Foo::Baz">],
     # ]
     # ```
-    sig { params(query: String, nesting: T::Array[String]).returns(T::Array[T::Array[Entry]]) }
-    def prefix_search(query, nesting)
+    sig { params(query: String, nesting: T.nilable(T::Array[String])).returns(T::Array[T::Array[Entry]]) }
+    def prefix_search(query, nesting = nil)
+      unless nesting
+        results = @entries_tree.search(query)
+        results.uniq!
+        return results
+      end
+
       results = nesting.length.downto(0).flat_map do |i|
         prefix = T.must(nesting[0...i]).join("::")
         namespaced_query = prefix.empty? ? query : "#{prefix}::#{query}"
@@ -180,8 +186,8 @@ module RubyIndexer
     def index_single(indexable_path, source = nil)
       content = source || File.read(indexable_path.full_path)
       result = Prism.parse(content)
-      visitor = IndexVisitor.new(self, result, indexable_path.full_path)
-      result.value.accept(visitor)
+      collector = Collector.new(self, result, indexable_path.full_path)
+      collector.collect(result.value)
 
       require_path = indexable_path.require_path
       @require_paths_tree.insert(require_path, indexable_path) if require_path
@@ -231,6 +237,18 @@ module RubyIndexer
       real_parts.join("::")
     end
 
+    # Attempts to find a given method for a resolved fully qualified receiver name. Returns `nil` if the method does not
+    # exist on that receiver
+    sig { params(method_name: String, receiver_name: String).returns(T.nilable(Entry::Method)) }
+    def resolve_method(method_name, receiver_name)
+      method_entries = T.cast(self[method_name], T.nilable(T::Array[Entry::Method]))
+      owner_entries = self[receiver_name]
+      return unless owner_entries && method_entries
+
+      owner_name = T.must(owner_entries.first).name
+      method_entries.find { |entry| entry.owner&.name == owner_name }
+    end
+
     private
 
     # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant

data/lib/ruby_indexer/ruby_indexer.rb

@@ -5,7 +5,7 @@ require "yaml"
 require "did_you_mean"
 
 require "ruby_indexer/lib/ruby_indexer/indexable_path"
-require "ruby_indexer/lib/ruby_indexer/visitor"
+require "ruby_indexer/lib/ruby_indexer/collector"
 require "ruby_indexer/lib/ruby_indexer/index"
 require "ruby_indexer/lib/ruby_indexer/entry"
 require "ruby_indexer/lib/ruby_indexer/configuration"

data/lib/ruby_indexer/test/index_test.rb

@@ -193,5 +193,58 @@ module RubyIndexer
 
       assert_instance_of(Entry::UnresolvedAlias, entry)
     end
+
+    def test_visitor_does_not_visit_unnecessary_nodes
+      concats = (0...10_000).map do |i|
+        <<~STRING
+          "string#{i}" \\
+        STRING
+      end.join
+
+      index(<<~RUBY)
+        module Foo
+          local_var = #{concats}
+            "final"
+          @class_instance_var = #{concats}
+            "final"
+          @@class_var = #{concats}
+            "final"
+          $global_var = #{concats}
+            "final"
+          CONST = #{concats}
+            "final"
+        end
+      RUBY
+    end
+
+    def test_resolve_method_with_known_receiver
+      index(<<~RUBY)
+        module Foo
+          module Bar
+            def baz; end
+          end
+        end
+      RUBY
+
+      entry = T.must(@index.resolve_method("baz", "Foo::Bar"))
+      assert_equal("baz", entry.name)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+    end
+
+    def test_prefix_search_for_methods
+      index(<<~RUBY)
+        module Foo
+          module Bar
+            def baz; end
+          end
+        end
+      RUBY
+
+      entries = @index.prefix_search("ba")
+      refute_empty(entries)
+
+      entry = T.must(entries.first).first
+      assert_equal("baz", entry.name)
+    end
   end
 end

data/lib/ruby_indexer/test/method_test.rb

@@ -69,5 +69,19 @@ module RubyIndexer
       assert_equal(:"(a, (b, ))", parameter.name)
       assert_instance_of(Entry::RequiredParameter, parameter)
     end
+
+    def test_keeps_track_of_method_owner
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      owner_name = T.must(entry.owner).name
+
+      assert_equal("Foo", owner_name)
+    end
   end
 end

data/lib/ruby_lsp/document.rb

@@ -4,6 +4,9 @@
 module RubyLsp
   class Document
     extend T::Sig
+    extend T::Helpers
+
+    abstract!
 
     PositionShape = T.type_alias { { line: Integer, character: Integer } }
     RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
@@ -28,8 +31,8 @@ module RubyLsp
       @source = T.let(source, String)
       @version = T.let(version, Integer)
       @uri = T.let(uri, URI::Generic)
-      @needs_parsing = T.let(false, T::Boolean)
-      @parse_result = T.let(Prism.parse(@source), Prism::ParseResult)
+      @needs_parsing = T.let(true, T::Boolean)
+      @parse_result = T.let(parse, Prism::ParseResult)
     end
 
     sig { returns(Prism::ProgramNode) }
@@ -91,13 +94,8 @@ module RubyLsp
       @cache.clear
     end
 
-    sig { void }
-    def parse
-      return unless @needs_parsing
-
-      @needs_parsing = false
-      @parse_result = Prism.parse(@source)
-    end
+    sig { abstract.returns(Prism::ParseResult) }
+    def parse; end
 
     sig { returns(T::Boolean) }
     def syntax_error?

data/lib/ruby_lsp/executor.rb

@@ -57,6 +57,8 @@ module RubyLsp
           warn(errored_addons.map(&:backtraces).join("\n\n"))
         end
 
+        RubyVM::YJIT.enable if defined? RubyVM::YJIT.enable
+
         perform_initial_indexing
         check_formatter_is_available
 
@@ -474,34 +476,32 @@ module RubyLsp
     def completion(uri, position)
       document = @store.get(uri)
 
-      char_position = document.create_scanner.find_char_position(position)
-
-      # When the user types in the first letter of a constant name, we actually receive the position of the next
-      # immediate character. We check to see if the character is uppercase and then remove the offset to try to locate
-      # the node, as it could not be a constant
-      target_node_types = if ("A".."Z").cover?(document.source[char_position - 1])
-        char_position -= 1
-        [Prism::ConstantReadNode, Prism::ConstantPathNode]
-      else
-        [Prism::CallNode]
-      end
-
-      matched, parent, nesting = document.locate(document.tree, char_position, node_types: target_node_types)
+      # Completion always receives the position immediately after the character that was just typed. Here we adjust it
+      # back by 1, so that we find the right node
+      char_position = document.create_scanner.find_char_position(position) - 1
+      matched, parent, nesting = document.locate(
+        document.tree,
+        char_position,
+        node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
+      )
       return unless matched && parent
 
       target = case matched
       when Prism::CallNode
         message = matched.message
-        return unless message == "require"
 
-        args = matched.arguments&.arguments
-        return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
+        if message == "require"
+          args = matched.arguments&.arguments
+          return if args.nil? || args.is_a?(Prism::ForwardingArgumentsNode)
 
-        argument = args.first
-        return unless argument.is_a?(Prism::StringNode)
-        return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
+          argument = args.first
+          return unless argument.is_a?(Prism::StringNode)
+          return unless (argument.location.start_offset..argument.location.end_offset).cover?(char_position)
 
-        argument
+          argument
+        else
+          matched
+        end
       when Prism::ConstantReadNode, Prism::ConstantPathNode
         if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
           parent
@@ -579,7 +579,7 @@ module RubyLsp
       # notification
     end
 
-    sig { params(options: T::Hash[Symbol, T.untyped]).returns(Interface::InitializeResult) }
+    sig { params(options: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
     def initialize_request(options)
       @store.clear
 
@@ -680,7 +680,7 @@ module RubyLsp
       completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
-          trigger_characters: ["/", *"A".."Z"],
+          trigger_characters: ["/"],
           completion_item: {
             labelDetailsSupport: true,
           },
@@ -716,7 +716,7 @@ module RubyLsp
 
       begin_progress("indexing-progress", "Ruby LSP: indexing files")
 
-      Interface::InitializeResult.new(
+      {
         capabilities: Interface::ServerCapabilities.new(
           text_document_sync: Interface::TextDocumentSyncOptions.new(
             change: Constant::TextDocumentSyncKind::INCREMENTAL,
@@ -740,7 +740,12 @@ module RubyLsp
           definition_provider: enabled_features["definition"],
           workspace_symbol_provider: enabled_features["workspaceSymbol"],
         ),
-      )
+        serverInfo: {
+          name: "Ruby LSP",
+          version: VERSION,
+        },
+        formatter: @store.formatter,
+      }
     end
 
     sig { void }

data/lib/ruby_lsp/internal.rb

@@ -24,6 +24,10 @@ require "ruby_lsp/server"
 require "ruby_lsp/executor"
 require "ruby_lsp/requests"
 require "ruby_lsp/listener"
+require "ruby_lsp/document"
+require "ruby_lsp/ruby_document"
 require "ruby_lsp/store"
 require "ruby_lsp/addon"
 require "ruby_lsp/requests/support/rubocop_runner"
+
+Bundler.ui.level = :silent

data/lib/ruby_lsp/requests/completion.rb

@@ -6,9 +6,14 @@ module RubyLsp
     # ![Completion demo](../../completion.gif)
     #
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
-    # suggests possible completions according to what the developer is typing. Currently, completion is support for
-    # - require paths
-    # - classes, modules and constant names
+    # suggests possible completions according to what the developer is typing.
+    #
+    # Currently supported targets:
+    # - Classes
+    # - Modules
+    # - Constants
+    # - Require paths
+    # - Methods invoked on self only
     #
     # # Example
     #
@@ -45,6 +50,7 @@ module RubyLsp
           :on_string_node_enter,
           :on_constant_path_node_enter,
           :on_constant_read_node_enter,
+          :on_call_node_enter,
         )
       end
 
@@ -118,17 +124,60 @@ module RubyLsp
         end
       end
 
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+        return unless self_receiver?(node)
+
+        name = node.message
+        return unless name
+
+        receiver_entries = @index[@nesting.join("::")]
+        return unless receiver_entries
+
+        receiver = T.must(receiver_entries.first)
+
+        candidates = T.cast(@index.prefix_search(name), T::Array[T::Array[RubyIndexer::Entry::Method]])
+        candidates.each do |entries|
+          entry = entries.find { |e| e.owner&.name == receiver.name }
+          next unless entry
+
+          @_response << build_method_completion(entry, node)
+        end
+      end
+
       private
 
+      sig { params(entry: RubyIndexer::Entry::Method, node: Prism::CallNode).returns(Interface::CompletionItem) }
+      def build_method_completion(entry, node)
+        name = entry.name
+        parameters = entry.parameters
+        new_text = parameters.empty? ? name : "#{name}(#{parameters.map(&:name).join(", ")})"
+
+        Interface::CompletionItem.new(
+          label: name,
+          filter_text: name,
+          text_edit: Interface::TextEdit.new(range: range_from_node(node), new_text: new_text),
+          kind: Constant::CompletionItemKind::METHOD,
+          label_details: Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+          ),
+          documentation: markdown_from_index_entries(name, entry),
+        )
+      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
+        loc = node.content_loc
+
         Interface::CompletionItem.new(
           label: label,
           text_edit: Interface::TextEdit.new(
-            range: range_from_node(node),
+            range: range_from_location(loc),
             new_text: label,
           ),
-          kind: Constant::CompletionItemKind::REFERENCE,
+          kind: Constant::CompletionItemKind::FILE,
         )
       end
 

data/lib/ruby_lsp/requests/definition.rb

@@ -9,7 +9,12 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
     # definition of the symbol under the cursor.
     #
-    # Currently, only jumping to classes, modules and required files is supported.
+    # Currently supported targets:
+    # - Classes
+    # - Modules
+    # - Constants
+    # - Require paths
+    # - Methods invoked on self only
     #
     # # Example
     #
@@ -75,8 +80,52 @@ module RubyLsp
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         message = node.name
-        return unless message == :require || message == :require_relative
 
+        if message == :require || message == :require_relative
+          handle_require_definition(node)
+        else
+          handle_method_definition(node)
+        end
+      end
+
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
+        find_in_index(node.slice)
+      end
+
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
+        find_in_index(node.slice)
+      end
+
+      private
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_method_definition(node)
+        return unless self_receiver?(node)
+
+        message = node.message
+        return unless message
+
+        target_method = @index.resolve_method(message, @nesting.join("::"))
+        return unless target_method
+
+        location = target_method.location
+        file_path = target_method.file_path
+        return if defined_in_gem?(file_path)
+
+        @_response = Interface::Location.new(
+          uri: URI::Generic.from_path(path: file_path).to_s,
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+            end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+          ),
+        )
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_require_definition(node)
+        message = node.name
         arguments = node.arguments
         return unless arguments
 
@@ -116,18 +165,6 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ConstantPathNode).void }
-      def on_constant_path_node_enter(node)
-        find_in_index(node.slice)
-      end
-
-      sig { params(node: Prism::ConstantReadNode).void }
-      def on_constant_read_node_enter(node)
-        find_in_index(node.slice)
-      end
-
-      private
-
       sig { params(value: String).void }
       def find_in_index(value)
         entries = @index.resolve(value, @nesting)
@@ -138,23 +175,13 @@ module RubyLsp
         first_entry = T.must(entries.first)
         return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{value}"
 
-        bundle_path = begin
-          Bundler.bundle_path.to_s
-        rescue Bundler::GemfileNotFound
-          nil
-        end
-
         @_response = entries.filter_map do |entry|
           location = entry.location
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
           # in the project, even if the files are typed false
           file_path = entry.file_path
-          if DependencyDetector.instance.typechecker && bundle_path && !file_path.start_with?(bundle_path) &&
-              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
-
-            next
-          end
+          next if defined_in_gem?(file_path)
 
           Interface::Location.new(
             uri: URI::Generic.from_path(path: file_path).to_s,

data/lib/ruby_lsp/requests/hover.rb

@@ -51,6 +51,7 @@ module RubyLsp
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
+          :on_call_node_enter,
         )
       end
 
@@ -95,6 +96,25 @@ module RubyLsp
         generate_hover(node.slice, node.location)
       end
 
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+        return unless self_receiver?(node)
+
+        message = node.message
+        return unless message
+
+        target_method = @index.resolve_method(message, @nesting.join("::"))
+        return unless target_method
+
+        location = target_method.location
+
+        @_response = Interface::Hover.new(
+          range: range_from_location(location),
+          contents: markdown_from_index_entries(message, target_method),
+        )
+      end
+
       private
 
       sig { params(name: String, location: Prism::Location).void }

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -18,6 +18,16 @@ module RubyLsp
     #   puts "handle some rescue"
     # end
     # ```
+    #
+    # # Example
+    #
+    # ```ruby
+    # var = "foo"
+    # {
+    #   var: var, # Label "var" goes here in cases where the value is omitted
+    #   a: "hello",
+    # }
+    # ```
     class InlayHints < Listener
       extend T::Sig
       extend T::Generic
@@ -36,7 +46,7 @@ module RubyLsp
         @_response = T.let([], ResponseType)
         @range = range
 
-        dispatcher.register(self, :on_rescue_node_enter)
+        dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end
 
       sig { params(node: Prism::RescueNode).void }
@@ -53,6 +63,34 @@ module RubyLsp
           tooltip: "StandardError is implied in a bare rescue",
         )
       end
+
+      sig { params(node: Prism::ImplicitNode).void }
+      def on_implicit_node_enter(node)
+        return unless visible?(node, @range)
+
+        node_value = node.value
+        loc = node.location
+        tooltip = ""
+        node_name = ""
+        case node_value
+        when Prism::CallNode
+          node_name = node_value.name
+          tooltip = "This is a method call. Method name: #{node_name}"
+        when Prism::ConstantReadNode
+          node_name = node_value.name
+          tooltip = "This is a constant: #{node_name}"
+        when Prism::LocalVariableReadNode
+          node_name = node_value.name
+          tooltip = "This is a local variable: #{node_name}"
+        end
+
+        @_response << Interface::InlayHint.new(
+          position: { line: loc.start_line - 1, character: loc.start_column + node_name.length + 1 },
+          label: node_name,
+          padding_left: true,
+          tooltip: tooltip,
+        )
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -51,7 +51,14 @@ module RubyLsp
           if (comment_match = @previous_line.match(/^#(\s*)/))
             handle_comment_line(T.must(comment_match[1]))
           elsif @document.syntax_error?
-            handle_statement_end
+            match = /(?<=<<(-|~))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
+            heredoc_delimiter = match && match.named_captures["delimiter"]
+
+            if heredoc_delimiter
+              handle_heredoc_end(heredoc_delimiter)
+            else
+              handle_statement_end
+            end
           end
         end
 
@@ -121,6 +128,14 @@ module RubyLsp
         end
       end
 
+      sig { params(delimiter: String).void }
+      def handle_heredoc_end(delimiter)
+        indents = " " * @indentation
+        add_edit_with_text("\n")
+        add_edit_with_text("#{indents}#{delimiter}")
+        move_cursor_to(@position[:line], @indentation + 2)
+      end
+
       sig { params(spaces: String).void }
       def handle_comment_line(spaces)
         add_edit_with_text("##{spaces}")

data/lib/ruby_lsp/requests/support/common.rb

@@ -9,6 +9,9 @@ module RubyLsp
         # https://github.com/Shopify/ruby-lsp-rails, or addons by created by developers outside of Shopify, so be
         # cautious of changing anything.
         extend T::Sig
+        extend T::Helpers
+
+        requires_ancestor { Kernel }
 
         sig { params(node: Prism::Node).returns(Interface::Range) }
         def range_from_node(node)
@@ -66,12 +69,29 @@ module RubyLsp
           )
         end
 
-        sig { params(title: String, entries: T::Array[RubyIndexer::Entry]).returns(Interface::MarkupContent) }
+        sig { params(file_path: String).returns(T.nilable(T::Boolean)) }
+        def defined_in_gem?(file_path)
+          DependencyDetector.instance.typechecker && BUNDLE_PATH && !file_path.start_with?(T.must(BUNDLE_PATH)) &&
+            !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+        end
+
+        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        def self_receiver?(node)
+          receiver = node.receiver
+          receiver.nil? || receiver.is_a?(Prism::SelfNode)
+        end
+
+        sig do
+          params(
+            title: String,
+            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
+          ).returns(Interface::MarkupContent)
+        end
         def markdown_from_index_entries(title, entries)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
           content = +""
-          entries.each do |entry|
+          Array(entries).each do |entry|
             loc = entry.location
 
             # We always handle locations as zero based. However, for file links in Markdown we need them to be one

data/lib/ruby_lsp/requests/support/dependency_detector.rb

@@ -66,7 +66,6 @@ module RubyLsp
 
     sig { returns(T::Array[String]) }
     def dependencies
-      # NOTE: If changing this behaviour, it's likely that the VS Code extension will also need changed.
       @dependencies ||= T.let(
         begin
           Bundler.with_original_env { Bundler.default_gemfile }

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -20,6 +20,7 @@ module RubyLsp
     #
     class WorkspaceSymbol
       extend T::Sig
+      include Support::Common
 
       sig { params(query: T.nilable(String), index: RubyIndexer::Index).void }
       def initialize(query, index)
@@ -29,21 +30,11 @@ module RubyLsp
 
       sig { returns(T::Array[Interface::WorkspaceSymbol]) }
       def run
-        bundle_path = begin
-          Bundler.bundle_path.to_s
-        rescue Bundler::GemfileNotFound
-          nil
-        end
-
         @index.fuzzy_search(@query).filter_map do |entry|
           # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
           # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          if DependencyDetector.instance.typechecker && bundle_path && !file_path.start_with?(bundle_path) &&
-              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
-
-            next
-          end
+          next if defined_in_gem?(file_path)
 
           # We should never show private symbols when searching the entire workspace
           next if entry.visibility == :private
@@ -82,6 +73,8 @@ module RubyLsp
           Constant::SymbolKind::NAMESPACE
         when RubyIndexer::Entry::Constant
           Constant::SymbolKind::CONSTANT
+        when RubyIndexer::Entry::Method
+          entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
         end
       end
     end

data/lib/ruby_lsp/ruby_document.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class RubyDocument < Document
+    sig { override.returns(Prism::ParseResult) }
+    def parse
+      return @parse_result unless @needs_parsing
+
+      @needs_parsing = false
+      @parse_result = Prism.parse(@source)
+    end
+  end
+end

data/lib/ruby_lsp/setup_bundler.rb

@@ -12,6 +12,8 @@ require "time"
 # the Ruby LSP without including the gem in their application's Gemfile while at the same time giving us access to the
 # exact locked versions of dependencies.
 
+Bundler.ui.level = :silent
+
 module RubyLsp
   class SetupBundler
     extend T::Sig

data/lib/ruby_lsp/store.rb

@@ -1,8 +1,6 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "ruby_lsp/document"
-
 module RubyLsp
   class Store
     extend T::Sig
@@ -40,7 +38,7 @@ module RubyLsp
 
     sig { params(uri: URI::Generic, source: String, version: Integer).void }
     def set(uri:, source:, version:)
-      document = Document.new(source: source, version: version, uri: uri, encoding: @encoding)
+      document = RubyDocument.new(source: source, version: version, uri: uri, encoding: @encoding)
       @state[uri.to_s] = document
     end
 

data/lib/ruby_lsp/utils.rb

@@ -8,6 +8,15 @@ module RubyLsp
   # This freeze is not redundant since the interpolated string is mutable
   WORKSPACE_URI = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
 
+  BUNDLE_PATH = T.let(
+    begin
+      Bundler.bundle_path.to_s
+    rescue Bundler::GemfileNotFound
+      nil
+    end,
+    T.nilable(String),
+  )
+
   # A notification to be sent to the client
   class Message
     extend T::Sig

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.12.3
+  version: 0.12.5
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-06 00:00:00.000000000 Z
+date: 2023-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -78,12 +78,12 @@ 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/collector.rb
 - lib/ruby_indexer/lib/ruby_indexer/configuration.rb
 - lib/ruby_indexer/lib/ruby_indexer/entry.rb
 - lib/ruby_indexer/lib/ruby_indexer/index.rb
 - lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
-- lib/ruby_indexer/lib/ruby_indexer/visitor.rb
 - lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
@@ -132,6 +132,7 @@ files:
 - lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_tree_formatting_runner.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
+- lib/ruby_lsp/ruby_document.rb
 - lib/ruby_lsp/server.rb
 - lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/store.rb