ruby-lsp 0.14.5 → 0.15.0

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -22,16 +22,19 @@ module RubyLsp
       SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
       DESCRIBE_KEYWORD = T.let(:describe, Symbol)
       IT_KEYWORD = T.let(:it, Symbol)
+      DYNAMIC_REFERENCE_MARKER = T.let("<dynamic_reference>", String)
 
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
+          global_state: GlobalState,
           uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, uri, dispatcher)
+      def initialize(response_builder, global_state, uri, dispatcher)
         @response_builder = response_builder
+        @global_state = global_state
         @uri = T.let(uri, URI::Generic)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         # visibility_stack is a stack of [current_visibility, previous_visibility]
@@ -44,6 +47,8 @@ module RubyLsp
           self,
           :on_class_node_enter,
           :on_class_node_leave,
+          :on_module_node_enter,
+          :on_module_node_leave,
           :on_def_node_enter,
           :on_call_node_enter,
           :on_call_node_leave,
@@ -60,7 +65,7 @@ module RubyLsp
           add_test_code_lens(
             node,
             name: class_name,
-            command: generate_test_command(group_name: class_name),
+            command: generate_test_command(group_stack: @group_stack),
             kind: :group,
           )
         end
@@ -88,13 +93,27 @@ module RubyLsp
             add_test_code_lens(
               node,
               name: method_name,
-              command: generate_test_command(method_name: method_name, group_name: class_name),
+              command: generate_test_command(method_name: method_name, group_stack: @group_stack),
               kind: :example,
             )
           end
         end
       end
 
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_enter(node)
+        if (path = namespace_constant_name(node))
+          @group_stack.push(path)
+        else
+          @group_stack.push(DYNAMIC_REFERENCE_MARKER)
+        end
+      end
+
+      sig { params(node: Prism::ModuleNode).void }
+      def on_module_node_leave(node)
+        @group_stack.pop
+      end
+
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         name = node.name
@@ -139,7 +158,7 @@ module RubyLsp
       sig { params(node: Prism::Node, name: String, command: String, kind: Symbol).void }
       def add_test_code_lens(node, name:, command:, kind:)
         # don't add code lenses if the test library is not supported or unknown
-        return unless SUPPORTED_TEST_LIBRARIES.include?(DependencyDetector.instance.detected_test_library) && @path
+        return unless SUPPORTED_TEST_LIBRARIES.include?(@global_state.test_library) && @path
 
         arguments = [
           @path,
@@ -181,18 +200,45 @@ module RubyLsp
         )
       end
 
-      sig { params(group_name: String, method_name: T.nilable(String)).returns(String) }
-      def generate_test_command(group_name:, method_name: nil)
+      sig do
+        params(
+          group_stack: T::Array[String],
+          spec_name: T.nilable(String),
+          method_name: T.nilable(String),
+        ).returns(String)
+      end
+      def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
         command = BASE_COMMAND + T.must(@path)
 
-        case DependencyDetector.instance.detected_test_library
+        case @global_state.test_library
         when "minitest"
-          command += if method_name
-            " --name " + "/#{Shellwords.escape(group_name + "#" + method_name)}/"
+          last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
+          command += if last_dynamic_reference_index
+            # In cases where the test path looks like `foo::Bar`
+            # the best we can do is match everything to the right of it.
+            # Tests are classes, dynamic references are only a thing for modules,
+            # so there must be something to the left of the available path.
+            group_stack = T.must(group_stack[last_dynamic_reference_index + 1..])
+            if method_name
+              " --name " + "/::#{Shellwords.escape(group_stack.join("::") + "#" + method_name)}$/"
+            else
+              # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
+              # that are registered on the class itself (matches after `#`) and all tests
+              # that are nested inside of that class in other modules/classes (matches after `::`)
+              " --name " + "\"/::#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
+            end
+          elsif method_name
+            # We know the entire path, do an exact match
+            " --name " + Shellwords.escape(group_stack.join("::") + "#" + method_name)
+          elsif spec_name
+            " --name " + "/#{Shellwords.escape(spec_name)}/"
           else
-            " --name " + "/#{Shellwords.escape(group_name)}/"
+            # Execute all tests of the selected class and tests in
+            # modules/classes nested inside of that class
+            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
           end
         when "test-unit"
+          group_name = T.must(group_stack.last)
           command += " --testcase " + "/#{Shellwords.escape(group_name)}/"
 
           if method_name
@@ -214,18 +260,20 @@ module RubyLsp
         name = case first_argument
         when Prism::StringNode
           first_argument.content
-        when Prism::ConstantReadNode
-          first_argument.full_name
+        when Prism::ConstantReadNode, Prism::ConstantPathNode
+          constant_name(first_argument)
         end
 
         return unless name
 
-        add_test_code_lens(
-          node,
-          name: name,
-          command: generate_test_command(group_name: name),
-          kind: kind,
-        )
+        if @path
+          add_test_code_lens(
+            node,
+            name: name,
+            command: generate_test_command(spec_name: name),
+            kind: kind,
+          )
+        end
       end
     end
   end

data/lib/ruby_lsp/listeners/completion.rb

@@ -10,16 +10,17 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           nesting: T::Array[String],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
         ).void
       end
-      def initialize(response_builder, index, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, nesting, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
-        @index = index
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @nesting = nesting
         @typechecker_enabled = typechecker_enabled
         @uri = uri
@@ -35,7 +36,7 @@ module RubyLsp
       # Handle completion on regular constant references (e.g. `Bar`)
       sig { params(node: Prism::ConstantReadNode).void }
       def on_constant_read_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?
@@ -56,7 +57,7 @@ module RubyLsp
       # Handle completion on namespaced constant references (e.g. `Foo::Bar`)
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?
@@ -77,7 +78,10 @@ module RubyLsp
 
         real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
 
-        candidates = @index.prefix_search("#{real_namespace}::#{incomplete_name}", top_level_reference ? [] : @nesting)
+        candidates = @index.prefix_search(
+          "#{real_namespace}::#{incomplete_name}",
+          top_level_reference ? [] : @nesting,
+        )
         candidates.each do |entries|
           # The only time we may have a private constant reference from outside of the namespace is if we're dealing
           # with ConstantPath and the entry name doesn't start with the current nesting
@@ -124,7 +128,9 @@ module RubyLsp
 
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        @index.search_require_paths(path_node_to_complete.content).map!(&:require_path).sort!.each do |path|
+        matched_indexable_paths = @index.search_require_paths(path_node_to_complete.content)
+
+        matched_indexable_paths.map!(&:require_path).sort!.each do |path|
           @response_builder << build_completion(T.must(path), path_node_to_complete)
         end
       end
@@ -284,13 +290,6 @@ module RubyLsp
             new_text: insertion_text,
           ),
           kind: kind,
-          label_details: Interface::CompletionItemLabelDetails.new(
-            description: entries.map(&:file_name).join(","),
-          ),
-          documentation: Interface::MarkupContent.new(
-            kind: "markdown",
-            value: markdown_from_index_entries(real_name, entries),
-          ),
         )
       end
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -10,18 +10,19 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::CollectionResponseBuilder[Interface::Location],
+          global_state: GlobalState,
           uri: URI::Generic,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, uri, nesting, index, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @uri = uri
         @nesting = nesting
-        @index = index
         @typechecker_enabled = typechecker_enabled
 
         dispatcher.register(

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -12,17 +12,20 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::DocumentSymbol,
+          uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(response_builder, dispatcher)
+      def initialize(response_builder, uri, dispatcher)
         @response_builder = response_builder
+        @uri = uri
 
         dispatcher.register(
           self,
           :on_class_node_enter,
           :on_class_node_leave,
           :on_call_node_enter,
+          :on_call_node_leave,
           :on_constant_path_write_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_or_write_node_enter,
@@ -79,10 +82,24 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        if ATTR_ACCESSORS.include?(node.name)
+        node_name = node.name
+        if ATTR_ACCESSORS.include?(node_name)
           handle_attr_accessor(node)
-        elsif node.name == :alias_method
+        elsif node_name == :alias_method
           handle_alias_method(node)
+        elsif node_name == :namespace
+          handle_rake_namespace(node)
+        elsif node_name == :task
+          handle_rake_task(node)
+        end
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_leave(node)
+        return unless rake?
+
+        if node.name == :namespace && !node.receiver
+          @response_builder.pop
         end
       end
 
@@ -279,6 +296,7 @@ module RubyLsp
         ).returns(Interface::DocumentSymbol)
       end
       def create_document_symbol(name:, kind:, range_location:, selection_range_location:)
+        name = "<blank>" if name.empty?
         symbol = Interface::DocumentSymbol.new(
           name: name,
           kind: kind,
@@ -357,6 +375,76 @@ module RubyLsp
           )
         end
       end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_rake_namespace(node)
+        return unless rake?
+        return if node.receiver
+
+        arguments = node.arguments
+        return unless arguments
+
+        name_argument = arguments.arguments.first
+        return unless name_argument
+
+        name = case name_argument
+        when Prism::StringNode then name_argument.content
+        when Prism::SymbolNode then name_argument.value
+        end
+
+        return if name.nil? || name.empty?
+
+        @response_builder << create_document_symbol(
+          name: name,
+          kind: Constant::SymbolKind::MODULE,
+          range_location: name_argument.location,
+          selection_range_location: name_argument.location,
+        )
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_rake_task(node)
+        return unless rake?
+        return if node.receiver
+
+        arguments = node.arguments
+        return unless arguments
+
+        name_argument = arguments.arguments.first
+        return unless name_argument
+
+        name = case name_argument
+        when Prism::StringNode then name_argument.content
+        when Prism::SymbolNode then name_argument.value
+        when Prism::KeywordHashNode
+          first_element = name_argument.elements.first
+          if first_element.is_a?(Prism::AssocNode)
+            key = first_element.key
+            case key
+            when Prism::StringNode then key.content
+            when Prism::SymbolNode then key.value
+            end
+          end
+        end
+
+        return if name.nil? || name.empty?
+
+        create_document_symbol(
+          name: name,
+          kind: Constant::SymbolKind::METHOD,
+          range_location: name_argument.location,
+          selection_range_location: name_argument.location,
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def rake?
+        if (path = @uri.to_standardized_path)
+          path.match?(/(Rakefile|\.rake)$/)
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/ruby_lsp/listeners/hover.rb

@@ -28,18 +28,19 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::Hover,
+          global_state: GlobalState,
           uri: URI::Generic,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
           typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, uri, nesting, index, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(response_builder, global_state, uri, nesting, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @nesting = nesting
-        @index = index
         @typechecker_enabled = typechecker_enabled
 
         dispatcher.register(
@@ -63,14 +64,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
       def on_constant_path_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @global_state.typechecker
 
         name = constant_name(node)
         return if name.nil?

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -10,21 +10,24 @@ module RubyLsp
       sig do
         params(
           response_builder: ResponseBuilders::SignatureHelp,
+          global_state: GlobalState,
           nesting: T::Array[String],
-          index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
+          typechecker_enabled: T::Boolean,
         ).void
       end
-      def initialize(response_builder, nesting, index, dispatcher)
+      def initialize(response_builder, global_state, nesting, dispatcher, typechecker_enabled)
+        @typechecker_enabled = typechecker_enabled
         @response_builder = response_builder
+        @global_state = global_state
+        @index = T.let(global_state.index, RubyIndexer::Index)
         @nesting = nesting
-        @index = index
         dispatcher.register(self, :on_call_node_enter)
       end
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return if DependencyDetector.instance.typechecker
+        return if @typechecker_enabled
         return unless self_receiver?(node)
 
         message = node.message

data/lib/ruby_lsp/load_sorbet.rb

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+begin
+  T::Configuration.default_checked_level = :never
+  # Suppresses call validation errors
+  T::Configuration.call_validation_error_handler = ->(*) {}
+  # Suppresses errors caused by T.cast, T.let, T.must, etc.
+  T::Configuration.inline_type_error_handler = ->(*) {}
+  # Suppresses errors caused by incorrect parameter ordering
+  T::Configuration.sig_validation_error_handler = ->(*) {}
+rescue
+  # Need this rescue so that if another gem has
+  # already set the checked level by the time we
+  # get to it, we don't fail outright.
+  nil
+end
+
+module RubyLsp
+  # No-op all inline type assertions defined in T
+  module InlineTypeAssertions
+    def absurd(value)
+      value
+    end
+
+    def any(type_a, type_b, *types)
+      T::Types::Union.new([type_a, type_b, *types])
+    end
+
+    def assert_type!(value, type, checked: true)
+      value
+    end
+
+    def bind(value, type, checked: true)
+      value
+    end
+
+    def cast(value, type, checked: true)
+      value
+    end
+
+    def let(value, type, checked: true)
+      value
+    end
+
+    def must(arg)
+      arg
+    end
+
+    def nilable(type)
+      T::Types::Union.new([type, T::Utils::Nilable::NIL_TYPE])
+    end
+
+    def unsafe(value)
+      value
+    end
+
+    T.singleton_class.prepend(self)
+  end
+end

data/lib/ruby_lsp/requests/code_lens.rb

@@ -34,20 +34,21 @@ module RubyLsp
 
       sig do
         params(
+          global_state: GlobalState,
           uri: URI::Generic,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(uri, dispatcher)
+      def initialize(global_state, uri, dispatcher)
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens],
         )
         super()
-        Listeners::CodeLens.new(@response_builder, uri, dispatcher)
+        Listeners::CodeLens.new(@response_builder, global_state, uri, dispatcher)
 
         Addon.addons.each do |addon|
-          addon.create_code_lens_listener(@response_builder, uri, dispatcher)
+          addon.create_code_lens_listener(@response_builder, global_state, uri, dispatcher)
         end
       end
 

data/lib/ruby_lsp/requests/completion.rb

@@ -33,7 +33,7 @@ module RubyLsp
         sig { returns(Interface::CompletionOptions) }
         def provider
           Interface::CompletionOptions.new(
-            resolve_provider: false,
+            resolve_provider: true,
             trigger_characters: ["/", "\"", "'"],
             completion_item: {
               labelDetailsSupport: true,
@@ -45,13 +45,13 @@ module RubyLsp
       sig do
         params(
           document: Document,
-          index: RubyIndexer::Index,
+          global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, index, position, typechecker_enabled, dispatcher)
+      def initialize(document, global_state, position, typechecker_enabled, dispatcher)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @dispatcher = dispatcher
@@ -68,7 +68,18 @@ module RubyLsp
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem],
         )
 
-        Listeners::Completion.new(@response_builder, index, nesting, typechecker_enabled, dispatcher, document.uri)
+        Listeners::Completion.new(
+          @response_builder,
+          global_state,
+          nesting,
+          typechecker_enabled,
+          dispatcher,
+          document.uri,
+        )
+
+        Addon.addons.each do |addon|
+          addon.create_completion_listener(@response_builder, global_state, nesting, dispatcher, document.uri)
+        end
 
         return unless matched && parent
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Completion resolve demo](../../completion_resolve.gif)
+    #
+    # The [completionItem/resolve](https://microsoft.github.io/language-server-protocol/specification#completionItem_resolve)
+    # request provides additional information about the currently selected completion. Specifically, the `labelDetails`
+    # and `documentation` fields are provided, which are omitted from the completion items returned by
+    # `textDocument/completion`.
+    #
+    # The `labelDetails` field lists the files where the completion item is defined, and the `documentation` field
+    # includes any available documentation for those definitions.
+    #
+    # At most 10 definitions are included, to ensure low latency during request processing and rendering the completion
+    # item.
+    #
+    # # Example
+    #
+    # ```ruby
+    # A # -> as the user cycles through completion items, the documentation will be resolved and displayed
+    # ```
+    class CompletionResolve < Request
+      extend T::Sig
+      include Requests::Support::Common
+
+      # set a limit on the number of documentation entries returned, to avoid rendering performance issues
+      # https://github.com/Shopify/ruby-lsp/pull/1798
+      MAX_DOCUMENTATION_ENTRIES = 10
+
+      sig { params(global_state: GlobalState, item: T::Hash[Symbol, T.untyped]).void }
+      def initialize(global_state, item)
+        super()
+        @index = T.let(global_state.index, RubyIndexer::Index)
+        @item = item
+      end
+
+      sig { override.returns(Interface::CompletionItem) }
+      def perform
+        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),
+          ),
+        )
+      end
+    end
+  end
+end