ruby-lsp 0.9.3 → 0.10.0

data/lib/ruby_indexer/test/prefix_tree_test.rb

@@ -0,0 +1,150 @@
+# typed: true
+# frozen_string_literal: true
+
+require "test_helper"
+
+module RubyIndexer
+  class PrefixTreeTest < Minitest::Test
+    def test_empty
+      tree = PrefixTree.new
+
+      assert_empty(tree.search(""))
+      assert_empty(tree.search("foo"))
+    end
+
+    def test_single_item
+      tree = PrefixTree.new
+      tree.insert("foo", "foo")
+
+      assert_equal(["foo"], tree.search(""))
+      assert_equal(["foo"], tree.search("foo"))
+      assert_empty(tree.search("bar"))
+    end
+
+    def test_multiple_items
+      tree = PrefixTree[String].new
+      ["foo", "bar", "baz"].each { |item| tree.insert(item, item) }
+
+      assert_equal(["foo", "bar", "baz"], tree.search(""))
+      assert_equal(["bar", "baz"], tree.search("b"))
+      assert_equal(["foo"], tree.search("fo"))
+      assert_equal(["bar", "baz"], tree.search("ba"))
+      assert_equal(["baz"], tree.search("baz"))
+      assert_empty(tree.search("qux"))
+    end
+
+    def test_multiple_prefixes
+      tree = PrefixTree[String].new
+      ["fo", "foo"].each { |item| tree.insert(item, item) }
+
+      assert_equal(["fo", "foo"], tree.search(""))
+      assert_equal(["fo", "foo"], tree.search("f"))
+      assert_equal(["fo", "foo"], tree.search("fo"))
+      assert_equal(["foo"], tree.search("foo"))
+      assert_empty(tree.search("fooo"))
+    end
+
+    def test_multiple_prefixes_with_shuffled_order
+      tree = PrefixTree[String].new
+      [
+        "foo/bar/base",
+        "foo/bar/on",
+        "foo/bar/support/selection",
+        "foo/bar/support/runner",
+        "foo/internal",
+        "foo/bar/document",
+        "foo/bar/code",
+        "foo/bar/support/rails",
+        "foo/bar/diagnostics",
+        "foo/bar/document2",
+        "foo/bar/support/runner2",
+        "foo/bar/support/diagnostic",
+        "foo/document",
+        "foo/bar/formatting",
+        "foo/bar/support/highlight",
+        "foo/bar/semantic",
+        "foo/bar/support/prefix",
+        "foo/bar/folding",
+        "foo/bar/selection",
+        "foo/bar/support/syntax",
+        "foo/bar/document3",
+        "foo/bar/hover",
+        "foo/bar/support/semantic",
+        "foo/bar/support/source",
+        "foo/bar/inlay",
+        "foo/requests",
+        "foo/bar/support/formatting",
+        "foo/bar/path",
+        "foo/executor",
+      ].each { |item| tree.insert(item, item) }
+
+      assert_equal(
+        [
+          "foo/bar/support/selection",
+          "foo/bar/support/semantic",
+          "foo/bar/support/syntax",
+          "foo/bar/support/source",
+          "foo/bar/support/runner",
+          "foo/bar/support/runner2",
+          "foo/bar/support/rails",
+          "foo/bar/support/diagnostic",
+          "foo/bar/support/highlight",
+          "foo/bar/support/prefix",
+          "foo/bar/support/formatting",
+        ],
+        tree.search("foo/bar/support"),
+      )
+    end
+
+    def test_deletion
+      tree = PrefixTree[String].new
+      ["foo/bar", "foo/baz"].each { |item| tree.insert(item, item) }
+      assert_equal(["foo/bar", "foo/baz"], tree.search("foo"))
+
+      tree.delete("foo/bar")
+      assert_empty(tree.search("foo/bar"))
+      assert_equal(["foo/baz"], tree.search("foo"))
+    end
+
+    def test_delete_does_not_impact_other_keys_with_the_same_value
+      tree = PrefixTree[String].new
+      tree.insert("key1", "value")
+      tree.insert("key2", "value")
+      assert_equal(["value", "value"], tree.search("key"))
+
+      tree.delete("key2")
+      assert_empty(tree.search("key2"))
+      assert_equal(["value"], tree.search("key1"))
+    end
+
+    def test_deleted_node_is_removed_from_the_tree
+      tree = PrefixTree[String].new
+      tree.insert("foo/bar", "foo/bar")
+      assert_equal(["foo/bar"], tree.search("foo"))
+
+      tree.delete("foo/bar")
+      root = tree.instance_variable_get(:@root)
+      assert_empty(root.children)
+    end
+
+    def test_deleting_non_terminal_nodes
+      tree = PrefixTree[String].new
+      tree.insert("abc", "value1")
+      tree.insert("abcdef", "value2")
+
+      tree.delete("abcdef")
+      assert_empty(tree.search("abcdef"))
+      assert_equal(["value1"], tree.search("abc"))
+    end
+
+    def test_overriding_values
+      tree = PrefixTree[Integer].new
+
+      tree.insert("foo/bar", 123)
+      assert_equal([123], tree.search("foo/bar"))
+
+      tree.insert("foo/bar", 456)
+      assert_equal([456], tree.search("foo/bar"))
+    end
+  end
+end

data/lib/ruby_indexer/test/test_case.rb

@@ -12,7 +12,7 @@ module RubyIndexer
     private
 
     def index(source)
-      @index.index_single("/fake/path/foo.rb", source)
+      @index.index_single(IndexablePath.new(nil, "/fake/path/foo.rb"), source)
     end
 
     def assert_entry(expected_name, type, expected_location)

data/lib/ruby_lsp/check_docs.rb

@@ -53,7 +53,8 @@ module RubyLsp
       # documented
       features = ObjectSpace.each_object(Class).filter_map do |k|
         klass = T.unsafe(k)
-        klass if klass < RubyLsp::Requests::BaseRequest || klass < RubyLsp::Listener
+        klass if klass < RubyLsp::Requests::BaseRequest ||
+          (klass < RubyLsp::Listener && klass != RubyLsp::ExtensibleListener)
       end
 
       missing_docs = T.let(Hash.new { |h, k| h[k] = [] }, T::Hash[String, T::Array[String]])

data/lib/ruby_lsp/event_emitter.rb

@@ -48,6 +48,8 @@ module RubyLsp
         @listeners[:on_const_path_ref]&.each { |l| T.unsafe(l).on_const_path_ref(node) }
       when SyntaxTree::Const
         @listeners[:on_const]&.each { |l| T.unsafe(l).on_const(node) }
+      when SyntaxTree::TopConstRef
+        @listeners[:on_top_const_ref]&.each { |l| T.unsafe(l).on_top_const_ref(node) }
       end
     end
 

data/lib/ruby_lsp/executor.rb

@@ -103,9 +103,6 @@ module RubyLsp
         semantic_highlighting = Requests::SemanticHighlighting.new(emitter, @message_queue)
         emitter.visit(document.tree) if document.parsed?
 
-        code_lens.merge_external_listeners_responses!
-        document_symbol.merge_external_listeners_responses!
-
         # 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/documentSymbol", document_symbol.response)
@@ -191,14 +188,17 @@ module RubyLsp
         file_path = uri.to_standardized_path
         next if file_path.nil? || File.directory?(file_path)
 
+        load_path_entry = $LOAD_PATH.find { |load_path| file_path.start_with?(load_path) }
+        indexable = RubyIndexer::IndexablePath.new(load_path_entry, file_path)
+
         case change[:type]
         when Constant::FileChangeType::CREATED
-          @index.index_single(file_path)
+          @index.index_single(indexable)
         when Constant::FileChangeType::CHANGED
-          @index.delete(file_path)
-          @index.index_single(file_path)
+          @index.delete(indexable)
+          @index.index_single(indexable)
         when Constant::FileChangeType::DELETED
-          @index.delete(file_path)
+          @index.delete(indexable)
         end
       end
 
@@ -296,11 +296,12 @@ module RubyLsp
       # Emit events for all listeners
       emitter.emit_for_target(target)
 
-      hover.merge_external_listeners_responses!
       hover.response
     end
 
-    sig { params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object) }
+    sig do
+      params(uri: URI::Generic, content_changes: T::Array[Document::EditShape], version: Integer).returns(Object)
+    end
     def text_document_did_change(uri, content_changes, version)
       @store.push_edits(uri: uri, edits: content_changes, version: version)
       VOID
@@ -473,12 +474,18 @@ module RubyLsp
       return unless document.parsed?
 
       char_position = document.create_scanner.find_char_position(position)
-      matched, parent = document.locate(
-        T.must(document.tree),
-        char_position,
-        node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
-      )
 
+      # 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
+        [SyntaxTree::Const, SyntaxTree::ConstPathRef, SyntaxTree::TopConstRef]
+      else
+        [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode]
+      end
+
+      matched, parent, nesting = document.locate(T.must(document.tree), char_position, node_types: target_node_types)
       return unless matched && parent
 
       target = case matched
@@ -499,12 +506,19 @@ module RubyLsp
         return unless (path_node.location.start_char..path_node.location.end_char).cover?(char_position)
 
         path_node
+      when SyntaxTree::Const, SyntaxTree::ConstPathRef
+        if (parent.is_a?(SyntaxTree::ConstPathRef) || parent.is_a?(SyntaxTree::TopConstRef)) &&
+            matched.is_a?(SyntaxTree::Const)
+          parent
+        else
+          matched
+        end
       end
 
       return unless target
 
       emitter = EventEmitter.new
-      listener = Requests::PathCompletion.new(emitter, @message_queue)
+      listener = Requests::Completion.new(@index, nesting, emitter, @message_queue)
       emitter.emit_for_target(target)
       listener.response
     end
@@ -640,7 +654,10 @@ module RubyLsp
       completion_provider = if enabled_features["completion"]
         Interface::CompletionOptions.new(
           resolve_provider: false,
-          trigger_characters: ["/"],
+          trigger_characters: ["/", *"A".."Z"],
+          completion_item: {
+            labelDetailsSupport: true,
+          },
         )
       end
 

data/lib/ruby_lsp/extension.rb

@@ -130,8 +130,20 @@ module RubyLsp
       overridable.params(
         emitter: EventEmitter,
         message_queue: Thread::Queue,
-      ).returns(T.nilable(Listener[T.nilable(Interface::DocumentSymbol)]))
+      ).returns(T.nilable(Listener[T::Array[Interface::DocumentSymbol]]))
     end
     def create_document_symbol_listener(emitter, message_queue); end
+
+    # Creates a new Definition listener. This method is invoked on every Definition request
+    sig do
+      overridable.params(
+        uri: URI::Generic,
+        nesting: T::Array[String],
+        index: RubyIndexer::Index,
+        emitter: EventEmitter,
+        message_queue: Thread::Queue,
+      ).returns(T.nilable(Listener[T.nilable(T.any(T::Array[Interface::Location], Interface::Location))]))
+    end
+    def create_definition_listener(uri, nesting, index, emitter, message_queue); end
   end
 end

data/lib/ruby_lsp/listener.rb

@@ -18,13 +18,42 @@ module RubyLsp
     def initialize(emitter, message_queue)
       @emitter = emitter
       @message_queue = message_queue
-      @external_listeners = T.let([], T::Array[RubyLsp::Listener[ResponseType]])
+    end
+
+    sig { returns(ResponseType) }
+    def response
+      _response
     end
 
     # Override this method with an attr_reader that returns the response of your listener. The listener should
     # accumulate results in a @response variable and then provide the reader so that it is accessible
     sig { abstract.returns(ResponseType) }
-    def response; end
+    def _response; end
+  end
+
+  # ExtensibleListener is an abstract class to be used by requests that accept extensions.
+  class ExtensibleListener < Listener
+    extend T::Sig
+    extend T::Generic
+
+    ResponseType = type_member
+
+    abstract!
+
+    # When inheriting from ExtensibleListener, the `super` of constructor must be called **after** the subclass's own
+    # ivars have been initialized. This is because the constructor of ExtensibleListener calls
+    # `initialize_external_listener` which may depend on the subclass's ivars.
+    sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+    def initialize(emitter, message_queue)
+      super
+      @response_merged = T.let(false, T::Boolean)
+      @external_listeners = T.let(
+        Extension.extensions.filter_map do |ext|
+          initialize_external_listener(ext)
+        end,
+        T::Array[RubyLsp::Listener[ResponseType]],
+      )
+    end
 
     # Merge responses from all external listeners into the base listener's response. We do this to return a single
     # response to the editor including the results of all extensions
@@ -33,11 +62,21 @@ module RubyLsp
       @external_listeners.each { |l| merge_response!(l) }
     end
 
+    sig { returns(ResponseType) }
+    def response
+      merge_external_listeners_responses! unless @response_merged
+      super
+    end
+
+    sig do
+      abstract.params(extension: RubyLsp::Extension).returns(T.nilable(RubyLsp::Listener[ResponseType]))
+    end
+    def initialize_external_listener(extension); end
+
     # Does nothing by default. Requests that accept extensions should override this method to define how to merge
     # responses coming from external listeners
-    sig { overridable.params(other: Listener[T.untyped]).returns(T.self_type) }
+    sig { abstract.params(other: Listener[T.untyped]).returns(T.self_type) }
     def merge_response!(other)
-      self
     end
   end
 end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -18,7 +18,7 @@ module RubyLsp
     # class Test < Minitest::Test
     # end
     # ```
-    class CodeLens < Listener
+    class CodeLens < ExtensibleListener
       extend T::Sig
       extend T::Generic
 
@@ -29,23 +29,20 @@ module RubyLsp
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
 
       sig { override.returns(ResponseType) }
-      attr_reader :response
+      attr_reader :_response
 
       sig { params(uri: URI::Generic, emitter: EventEmitter, message_queue: Thread::Queue, test_library: String).void }
       def initialize(uri, emitter, message_queue, test_library)
-        super(emitter, message_queue)
-
         @uri = T.let(uri, URI::Generic)
-        @external_listeners.concat(
-          Extension.extensions.filter_map { |ext| ext.create_code_lens_listener(uri, emitter, message_queue) },
-        )
         @test_library = T.let(test_library, String)
-        @response = T.let([], ResponseType)
+        @_response = T.let([], ResponseType)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
         @visibility_stack = T.let([["public", "public"]], T::Array[T::Array[T.nilable(String)]])
         @class_stack = T.let([], T::Array[String])
 
+        super(emitter, message_queue)
+
         emitter.register(
           self,
           :on_class,
@@ -149,9 +146,14 @@ module RubyLsp
         end
       end
 
+      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(extension)
+        extension.create_code_lens_listener(@uri, @emitter, @message_queue)
+      end
+
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
       def merge_response!(other)
-        @response.concat(other.response)
+        @_response.concat(other.response)
         self
       end
 
@@ -174,7 +176,7 @@ module RubyLsp
           },
         ]
 
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Run",
           command_name: "rubyLsp.runTest",
@@ -182,7 +184,7 @@ module RubyLsp
           data: { type: "test", kind: kind },
         )
 
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Run In Terminal",
           command_name: "rubyLsp.runTestInTerminal",
@@ -190,7 +192,7 @@ module RubyLsp
           data: { type: "test_in_terminal", kind: kind },
         )
 
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Debug",
           command_name: "rubyLsp.debugTest",
@@ -239,7 +241,7 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Command, remote: String).void }
       def add_open_gem_remote_code_lens(node, remote)
-        @response << create_code_lens(
+        @_response << create_code_lens(
           node,
           title: "Open remote",
           command_name: "rubyLsp.openLink",

data/lib/ruby_lsp/requests/completion.rb

@@ -0,0 +1,168 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![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
+    #
+    # # Example
+    #
+    # ```ruby
+    # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
+    #
+    # RubyLsp::Requests:: # --> completion: suggests `Completion`, `Hover`, ...
+    # ```
+    class Completion < Listener
+      extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
+
+      sig { override.returns(ResponseType) }
+      attr_reader :_response
+
+      sig do
+        params(
+          index: RubyIndexer::Index,
+          nesting: T::Array[String],
+          emitter: EventEmitter,
+          message_queue: Thread::Queue,
+        ).void
+      end
+      def initialize(index, nesting, emitter, message_queue)
+        super(emitter, message_queue)
+        @_response = T.let([], ResponseType)
+        @index = index
+        @nesting = nesting
+
+        emitter.register(self, :on_tstring_content, :on_const_path_ref, :on_const, :on_top_const_ref)
+      end
+
+      sig { params(node: SyntaxTree::TStringContent).void }
+      def on_tstring_content(node)
+        @index.search_require_paths(node.value).map!(&:require_path).sort!.each do |path|
+          @_response << build_completion(T.must(path), node)
+        end
+      end
+
+      # Handle completion on regular constant references (e.g. `Bar`)
+      sig { params(node: SyntaxTree::Const).void }
+      def on_const(node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = node.value
+        candidates = @index.prefix_search(name, @nesting)
+        candidates.each do |entries|
+          @_response << build_entry_completion(name, node, entries, top_level?(T.must(entries.first).name, candidates))
+        end
+      end
+
+      # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = full_constant_name(node)
+        candidates = @index.prefix_search(name, @nesting)
+        candidates.each do |entries|
+          @_response << build_entry_completion(name, node, entries, top_level?(T.must(entries.first).name, candidates))
+        end
+      end
+
+      # Handle completion on top level constant references (e.g. `::Bar`)
+      sig { params(node: SyntaxTree::TopConstRef).void }
+      def on_top_const_ref(node)
+        return if DependencyDetector::HAS_TYPECHECKER
+
+        name = full_constant_name(node)
+        candidates = @index.prefix_search(name, [])
+        candidates.each { |entries| @_response << build_entry_completion(name, node, entries, true) }
+      end
+
+      private
+
+      sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
+      def build_completion(label, node)
+        Interface::CompletionItem.new(
+          label: label,
+          text_edit: Interface::TextEdit.new(
+            range: range_from_syntax_tree_node(node),
+            new_text: label,
+          ),
+          kind: Constant::CompletionItemKind::REFERENCE,
+        )
+      end
+
+      sig do
+        params(
+          name: String,
+          node: SyntaxTree::Node,
+          entries: T::Array[RubyIndexer::Index::Entry],
+          top_level: T::Boolean,
+        ).returns(Interface::CompletionItem)
+      end
+      def build_entry_completion(name, node, entries, top_level)
+        first_entry = T.must(entries.first)
+        kind = case first_entry
+        when RubyIndexer::Index::Entry::Class
+          Constant::CompletionItemKind::CLASS
+        when RubyIndexer::Index::Entry::Module
+          Constant::CompletionItemKind::MODULE
+        when RubyIndexer::Index::Entry::Constant
+          Constant::CompletionItemKind::CONSTANT
+        else
+          Constant::CompletionItemKind::REFERENCE
+        end
+
+        insertion_text = first_entry.name.dup
+
+        # If we have two entries with the same name inside the current namespace and the user selects the top level
+        # option, we have to ensure it's prefixed with `::` or else we're completing the wrong constant. For example:
+        # If we have the index with ["Foo::Bar", "Bar"], and we're providing suggestions for `B` inside a `Foo` module,
+        # then selecting the `Foo::Bar` option needs to complete to `Bar` and selecting the top level `Bar` option needs
+        # to complete to `::Bar`.
+        insertion_text.prepend("::") if top_level
+
+        # If the user is searching for a constant inside the current namespace, then we prefer completing the short name
+        # of that constant. E.g.:
+        #
+        # module Foo
+        #  class Bar
+        #  end
+        #
+        #  Foo::B # --> completion inserts `Bar` instead of `Foo::Bar`
+        # end
+        @nesting.each { |namespace| insertion_text.delete_prefix!("#{namespace}::") }
+
+        # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
+        # For these top level references, we need to include the `::` as part of the filter text or else it won't match
+        # the right entries in the index
+        Interface::CompletionItem.new(
+          label: first_entry.name,
+          filter_text: top_level ? "::#{first_entry.name}" : first_entry.name,
+          text_edit: Interface::TextEdit.new(
+            range: range_from_syntax_tree_node(node),
+            new_text: insertion_text,
+          ),
+          kind: kind,
+          label_details: Interface::CompletionItemLabelDetails.new(
+            description: entries.map(&:file_name).join(","),
+          ),
+          documentation: markdown_from_index_entries(first_entry.name, entries),
+        )
+      end
+
+      # Check if the `entry_name` has potential conflicts in `candidates`, so that we use a top level reference instead
+      # of a short name
+      sig { params(entry_name: String, candidates: T::Array[T::Array[RubyIndexer::Index::Entry]]).returns(T::Boolean) }
+      def top_level?(entry_name, candidates)
+        candidates.any? { |entries| T.must(entries.first).name == "#{@nesting.join("::")}::#{entry_name}" }
+      end
+    end
+  end
+end