ruby-lsp 0.16.5 → 0.16.7

data/lib/ruby_indexer/test/method_test.rb

@@ -16,6 +16,17 @@ module RubyIndexer
       assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
     end
 
+    def test_conditional_method
+      index(<<~RUBY)
+        class Foo
+          def bar
+          end if condition
+        end
+      RUBY
+
+      assert_entry("bar", Entry::InstanceMethod, "/fake/path/foo.rb:1-2:2-5")
+    end
+
     def test_singleton_method_using_self_receiver
       index(<<~RUBY)
         class Foo
@@ -38,6 +49,28 @@ module RubyIndexer
       assert_no_entry("bar")
     end
 
+    def test_method_under_dynamic_class_or_module
+      index(<<~RUBY)
+        module Foo
+          class self::Bar
+            def bar
+            end
+          end
+        end
+
+        module Bar
+          def bar
+          end
+        end
+      RUBY
+
+      assert_equal(2, @index["bar"].length)
+      first_entry = T.must(@index["bar"].first)
+      assert_equal("Foo::self::Bar", first_entry.owner.name)
+      second_entry = T.must(@index["bar"].last)
+      assert_equal("Bar", second_entry.owner.name)
+    end
+
     def test_method_with_parameters
       index(<<~RUBY)
         class Foo
@@ -285,5 +318,28 @@ module RubyIndexer
 
       assert_no_entry("bar")
     end
+
+    def test_properly_tracks_multiple_levels_of_nesting
+      index(<<~RUBY)
+        module Foo
+          def first; end
+
+          module Bar
+            def second; end
+          end
+
+          def third; end
+        end
+      RUBY
+
+      entry = T.must(@index["first"]&.first)
+      assert_equal("Foo", T.must(entry.owner).name)
+
+      entry = T.must(@index["second"]&.first)
+      assert_equal("Foo::Bar", T.must(entry.owner).name)
+
+      entry = T.must(@index["third"]&.first)
+      assert_equal("Foo", T.must(entry.owner).name)
+    end
   end
 end

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -42,6 +42,8 @@ module RubyLsp
         @group_stack = T.let([], T::Array[String])
         @group_id = T.let(1, Integer)
         @group_id_stack = T.let([], T::Array[Integer])
+        # We want to avoid adding code lenses for nested definitions
+        @def_depth = T.let(0, Integer)
 
         dispatcher.register(
           self,
@@ -50,6 +52,7 @@ module RubyLsp
           :on_module_node_enter,
           :on_module_node_leave,
           :on_def_node_enter,
+          :on_def_node_leave,
           :on_call_node_enter,
           :on_call_node_leave,
         )
@@ -88,6 +91,9 @@ module RubyLsp
 
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
+        @def_depth += 1
+        return if @def_depth > 1
+
         class_name = @group_stack.last
         return unless class_name&.end_with?("Test")
 
@@ -105,6 +111,11 @@ module RubyLsp
         end
       end
 
+      sig { params(node: Prism::DefNode).void }
+      def on_def_node_leave(node)
+        @def_depth -= 1
+      end
+
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
         if (path = namespace_constant_name(node))

data/lib/ruby_lsp/listeners/completion.rb

@@ -47,7 +47,7 @@ module RubyLsp
           @response_builder << build_entry_completion(
             complete_name,
             name,
-            node,
+            range_from_location(node.location),
             entries,
             top_level?(complete_name),
           )
@@ -62,6 +62,53 @@ module RubyLsp
         name = constant_name(node)
         return if name.nil?
 
+        constant_path_completion(name, range_from_location(node.location))
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        receiver = node.receiver
+
+        # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke singleton
+        # methods). However, in addition to providing method completion, we also need to show possible constant
+        # completions
+        if (receiver.is_a?(Prism::ConstantReadNode) || receiver.is_a?(Prism::ConstantPathNode)) &&
+            node.call_operator == "::"
+
+          name = constant_name(receiver)
+
+          if name
+            start_loc = node.location
+            end_loc = T.must(node.call_operator_loc)
+
+            constant_path_completion(
+              "#{name}::",
+              Interface::Range.new(
+                start: Interface::Position.new(line: start_loc.start_line - 1, character: start_loc.start_column),
+                end: Interface::Position.new(line: end_loc.end_line - 1, character: end_loc.end_column),
+              ),
+            )
+            return
+          end
+        end
+
+        name = node.message
+        return unless name
+
+        case name
+        when "require"
+          complete_require(node)
+        when "require_relative"
+          complete_require_relative(node)
+        else
+          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
+        end
+      end
+
+      private
+
+      sig { params(name: String, range: Interface::Range).void }
+      def constant_path_completion(name, range)
         top_level_reference = if name.start_with?("::")
           name = name.delete_prefix("::")
           true
@@ -71,8 +118,13 @@ module RubyLsp
 
         # If we're trying to provide completion for an aliased namespace, we need to first discover it's real name in
         # order to find which possible constants match the desired search
-        *namespace, incomplete_name = name.split("::")
-        aliased_namespace = T.must(namespace).join("::")
+        aliased_namespace = if name.end_with?("::")
+          name.delete_suffix("::")
+        else
+          *namespace, incomplete_name = name.split("::")
+          T.must(namespace).join("::")
+        end
+
         namespace_entries = @index.resolve(aliased_namespace, @nesting)
         return unless namespace_entries
 
@@ -88,37 +140,19 @@ module RubyLsp
           first_entry = T.must(entries.first)
           next if first_entry.visibility == :private && !first_entry.name.start_with?("#{@nesting}::")
 
-          constant_name = T.must(first_entry.name.split("::").last)
-
+          constant_name = first_entry.name.delete_prefix("#{real_namespace}::")
           full_name = aliased_namespace.empty? ? constant_name : "#{aliased_namespace}::#{constant_name}"
 
           @response_builder << build_entry_completion(
             full_name,
             name,
-            node,
+            range,
             entries,
             top_level_reference || top_level?(T.must(entries.first).name),
           )
         end
       end
 
-      sig { params(node: Prism::CallNode).void }
-      def on_call_node_enter(node)
-        name = node.message
-        return unless name
-
-        case name
-        when "require"
-          complete_require(node)
-        when "require_relative"
-          complete_require_relative(node)
-        else
-          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
-        end
-      end
-
-      private
-
       sig { params(node: Prism::CallNode).void }
       def complete_require(node)
         arguments_node = node.arguments
@@ -223,12 +257,12 @@ module RubyLsp
         params(
           real_name: String,
           incomplete_name: String,
-          node: Prism::Node,
+          range: Interface::Range,
           entries: T::Array[RubyIndexer::Entry],
           top_level: T::Boolean,
         ).returns(Interface::CompletionItem)
       end
-      def build_entry_completion(real_name, incomplete_name, node, entries, top_level)
+      def build_entry_completion(real_name, incomplete_name, range, entries, top_level)
         first_entry = T.must(entries.first)
         kind = case first_entry
         when RubyIndexer::Entry::Class
@@ -263,20 +297,22 @@ module RubyLsp
         #
         #  Foo::B # --> completion inserts `Bar` instead of `Foo::Bar`
         # end
-        @nesting.each do |namespace|
-          prefix = "#{namespace}::"
-          shortened_name = insertion_text.delete_prefix(prefix)
-
-          # If a different entry exists for the shortened name, then there's a conflict and we should not shorten it
-          conflict_name = "#{@nesting.join("::")}::#{shortened_name}"
-          break if real_name != conflict_name && @index[conflict_name]
-
-          insertion_text = shortened_name
-
-          # If the user is typing a fully qualified name `Foo::Bar::Baz`, then we should not use the short name (e.g.:
-          # `Baz`) as filtering. So we only shorten the filter text if the user is not including the namespaces in their
-          # typing
-          filter_text.delete_prefix!(prefix) unless incomplete_name.start_with?(prefix)
+        unless @nesting.join("::").start_with?(incomplete_name)
+          @nesting.each do |namespace|
+            prefix = "#{namespace}::"
+            shortened_name = insertion_text.delete_prefix(prefix)
+
+            # If a different entry exists for the shortened name, then there's a conflict and we should not shorten it
+            conflict_name = "#{@nesting.join("::")}::#{shortened_name}"
+            break if real_name != conflict_name && @index[conflict_name]
+
+            insertion_text = shortened_name
+
+            # If the user is typing a fully qualified name `Foo::Bar::Baz`, then we should not use the short name (e.g.:
+            # `Baz`) as filtering. So we only shorten the filter text if the user is not including the namespaces in
+            # their typing
+            filter_text.delete_prefix!(prefix) unless incomplete_name.start_with?(prefix)
+          end
         end
 
         # When using a top level constant reference (e.g.: `::Bar`), the editor includes the `::` as part of the filter.
@@ -286,7 +322,7 @@ module RubyLsp
           label: real_name,
           filter_text: filter_text,
           text_edit: Interface::TextEdit.new(
-            range: range_from_node(node),
+            range: range,
             new_text: insertion_text,
           ),
           kind: kind,

data/lib/ruby_lsp/listeners/definition.rb

@@ -30,6 +30,7 @@ module RubyLsp
         dispatcher.register(
           self,
           :on_call_node_enter,
+          :on_block_argument_node_enter,
           :on_constant_read_node_enter,
           :on_constant_path_node_enter,
         )
@@ -42,10 +43,21 @@ module RubyLsp
         if message == :require || message == :require_relative
           handle_require_definition(node)
         else
-          handle_method_definition(node)
+          handle_method_definition(message.to_s, self_receiver?(node))
         end
       end
 
+      sig { params(node: Prism::BlockArgumentNode).void }
+      def on_block_argument_node_enter(node)
+        expression = node.expression
+        return unless expression.is_a?(Prism::SymbolNode)
+
+        value = expression.value
+        return unless value
+
+        handle_method_definition(value, false)
+      end
+
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
         name = constant_name(node)
@@ -64,12 +76,9 @@ module RubyLsp
 
       private
 
-      sig { params(node: Prism::CallNode).void }
-      def handle_method_definition(node)
-        message = node.message
-        return unless message
-
-        methods = if self_receiver?(node)
+      sig { params(message: String, self_receiver: T::Boolean).void }
+      def handle_method_definition(message, self_receiver)
+        methods = if self_receiver
           @index.resolve_method(message, @nesting.join("::"))
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -271,7 +271,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         return unless matches?(node, CONSTANT_PATH_NODES)
 
-        add_highlight(Constant::DocumentHighlightKind::READ, node.location)
+        add_highlight(Constant::DocumentHighlightKind::READ, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantReadNode).void }

data/lib/ruby_lsp/listeners/document_link.rb

@@ -30,7 +30,7 @@ module RubyLsp
                 lookup[spec.name] = {}
                 lookup[spec.name][spec.version.to_s] = {}
 
-                Dir.glob("**/*.rb", base: "#{spec.full_gem_path}/").each do |path|
+                Dir.glob("**/*.rb", base: "#{spec.full_gem_path.delete_prefix("//?/")}/").each do |path|
                   lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
                 end
               end

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -58,6 +58,7 @@ module RubyLsp
           :on_constant_operator_write_node_enter,
           :on_constant_or_write_node_enter,
           :on_constant_target_node_enter,
+          :on_constant_path_node_enter,
           :on_local_variable_and_write_node_enter,
           :on_local_variable_operator_write_node_enter,
           :on_local_variable_or_write_node_enter,
@@ -302,17 +303,64 @@ module RubyLsp
       def on_class_node_enter(node)
         return unless visible?(node, @range)
 
-        @response_builder.add_token(node.constant_path.location, :class, [:declaration])
+        constant_path = node.constant_path
+
+        if constant_path.is_a?(Prism::ConstantReadNode)
+          @response_builder.add_token(constant_path.location, :class, [:declaration])
+        else
+          each_constant_path_part(constant_path) do |part|
+            loc = case part
+            when Prism::ConstantPathNode
+              part.name_loc
+            when Prism::ConstantReadNode
+              part.location
+            end
+            next unless loc
+
+            @response_builder.add_token(loc, :class, [:declaration])
+          end
+        end
 
         superclass = node.superclass
-        @response_builder.add_token(superclass.location, :class) if superclass
+
+        if superclass.is_a?(Prism::ConstantReadNode)
+          @response_builder.add_token(superclass.location, :class)
+        elsif superclass
+          each_constant_path_part(superclass) do |part|
+            loc = case part
+            when Prism::ConstantPathNode
+              part.name_loc
+            when Prism::ConstantReadNode
+              part.location
+            end
+            next unless loc
+
+            @response_builder.add_token(loc, :class)
+          end
+        end
       end
 
       sig { params(node: Prism::ModuleNode).void }
       def on_module_node_enter(node)
         return unless visible?(node, @range)
 
-        @response_builder.add_token(node.constant_path.location, :namespace, [:declaration])
+        constant_path = node.constant_path
+
+        if constant_path.is_a?(Prism::ConstantReadNode)
+          @response_builder.add_token(constant_path.location, :namespace, [:declaration])
+        else
+          each_constant_path_part(constant_path) do |part|
+            loc = case part
+            when Prism::ConstantPathNode
+              part.name_loc
+            when Prism::ConstantReadNode
+              part.location
+            end
+            next unless loc
+
+            @response_builder.add_token(loc, :namespace, [:declaration])
+          end
+        end
       end
 
       sig { params(node: Prism::ImplicitNode).void }
@@ -327,6 +375,14 @@ module RubyLsp
         @inside_implicit_node = false
       end
 
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
+        return if @inside_implicit_node
+        return unless visible?(node, @range)
+
+        @response_builder.add_token(node.name_loc, :namespace)
+      end
+
       private
 
       # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that

data/lib/ruby_lsp/requests/completion.rb

@@ -11,6 +11,7 @@ module RubyLsp
     # suggests possible completions according to what the developer is typing.
     #
     # Currently supported targets:
+    #
     # - Classes
     # - Modules
     # - Constants
@@ -34,7 +35,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'"],
+            trigger_characters: ["/", "\"", "'", ":"],
             completion_item: {
               labelDetailsSupport: true,
             },

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -36,20 +36,27 @@ module RubyLsp
         @item = item
       end
 
-      sig { override.returns(Interface::CompletionItem) }
+      sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def perform
+        # 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 label details and documentation. If we modify anything, the completion behaviour might be broken.
+        #
+        # For example, forgetting to return the `insertText` included in the original item will make the editor use the
+        # `label` for the text edit instead
         label = @item[:label]
         entries = @index[label] || []
-        Interface::CompletionItem.new(
-          label: label,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),
-          ),
+
+        @item[:labelDetails] = Interface::CompletionItemLabelDetails.new(
+          description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
+        )
+
+        @item[:documentation] = Interface::MarkupContent.new(
+          kind: "markdown",
+          value: markdown_from_index_entries(label, entries, MAX_DOCUMENTATION_ENTRIES),
         )
+
+        @item
       end
     end
   end

data/lib/ruby_lsp/requests/definition.rb

@@ -12,6 +12,7 @@ module RubyLsp
     # definition of the symbol under the cursor.
     #
     # Currently supported targets:
+    #
     # - Classes
     # - Modules
     # - Constants
@@ -43,40 +44,49 @@ module RubyLsp
           ResponseBuilders::CollectionResponseBuilder[Interface::Location].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::Location],
         )
+        @dispatcher = dispatcher
 
         target, parent, nesting = document.locate_node(
           position,
-          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
+          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::BlockArgumentNode],
         )
 
         if target.is_a?(Prism::ConstantReadNode) && parent.is_a?(Prism::ConstantPathNode)
+          # If the target is part of a constant path node, we need to find the exact portion of the constant that the
+          # user is requesting to go to definition for
           target = determine_target(
             target,
             parent,
             position,
           )
+        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
+            !covers_position?(target.message_loc, position)
+          # If the target is a method call, we need to ensure that the requested position is exactly on top of the
+          # method identifier. Otherwise, we risk showing definitions for unrelated things
+          target = nil
         end
 
-        Listeners::Definition.new(
-          @response_builder,
-          global_state,
-          document.uri,
-          nesting,
-          dispatcher,
-          typechecker_enabled,
-        )
+        if target
+          Listeners::Definition.new(
+            @response_builder,
+            global_state,
+            document.uri,
+            nesting,
+            dispatcher,
+            typechecker_enabled,
+          )
 
-        Addon.addons.each do |addon|
-          addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+          Addon.addons.each do |addon|
+            addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+          end
         end
 
         @target = T.let(target, T.nilable(Prism::Node))
-        @dispatcher = dispatcher
       end
 
       sig { override.returns(T::Array[Interface::Location]) }
       def perform
-        @dispatcher.dispatch_once(@target)
+        @dispatcher.dispatch_once(@target) if @target
         @response_builder.response
       end
     end

data/lib/ruby_lsp/requests/hover.rb

@@ -41,25 +41,29 @@ module RubyLsp
       end
       def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
-        @target = T.let(nil, T.nilable(Prism::Node))
-        @target, parent, nesting = document.locate_node(
+        target, parent, nesting = document.locate_node(
           position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
         )
 
         if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
-            !Listeners::Hover::ALLOWED_TARGETS.include?(@target.class)) ||
-            (parent.is_a?(Prism::ConstantPathNode) && @target.is_a?(Prism::ConstantReadNode))
-          @target = determine_target(
-            T.must(@target),
+            !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
+            (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
+          target = determine_target(
+            T.must(target),
             T.must(parent),
             position,
           )
+        elsif target.is_a?(Prism::CallNode) && target.name != :require && target.name != :require_relative &&
+            !covers_position?(target.message_loc, position)
+
+          target = nil
         end
 
         # Don't need to instantiate any listeners if there's no target
-        return unless @target
+        return unless target
 
+        @target = T.let(target, T.nilable(Prism::Node))
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
         Listeners::Hover.new(@response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled)

data/lib/ruby_lsp/requests/request.rb

@@ -65,6 +65,20 @@ module RubyLsp
 
         target
       end
+
+      # Checks if a given location covers the position requested
+      sig { params(location: T.nilable(Prism::Location), position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      def covers_position?(location, position)
+        return false unless location
+
+        start_line = location.start_line - 1
+        end_line = location.end_line - 1
+        line = position[:line]
+        character = position[:character]
+
+        (start_line < line || (start_line == line && location.start_column <= character)) &&
+          (end_line > line || (end_line == line && location.end_column >= character))
+      end
     end
   end
 end

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

@@ -50,12 +50,12 @@ module RubyLsp
           params(
             node: Prism::Node,
             title: String,
-            command_name: String,
+            command_name: T.nilable(String),
             arguments: T.nilable(T::Array[T.untyped]),
             data: T.nilable(T::Hash[T.untyped, T.untyped]),
           ).returns(Interface::CodeLens)
         end
-        def create_code_lens(node, title:, command_name:, arguments:, data:)
+        def create_code_lens(node, title:, command_name: nil, arguments: nil, data: nil)
           range = range_from_node(node)
 
           Interface::CodeLens.new(
@@ -167,6 +167,24 @@ module RubyLsp
             constant_name(path)
           end
         end
+
+        # Iterates over each part of a constant path, so that we can easily push response items for each section of the
+        # name. For example, for `Foo::Bar::Baz`, this method will invoke the block with `Foo`, then `Bar` and finally
+        # `Baz`.
+        sig do
+          params(
+            node: Prism::Node,
+            block: T.proc.params(part: Prism::Node).void,
+          ).void
+        end
+        def each_constant_path_part(node, &block)
+          current = T.let(node, T.nilable(Prism::Node))
+
+          while current.is_a?(Prism::ConstantPathNode)
+            block.call(current)
+            current = current.parent
+          end
+        end
       end
     end
   end