ruby-lsp 0.17.2 → 0.17.4

data/lib/ruby_lsp/listeners/completion.rb

@@ -15,15 +15,26 @@ module RubyLsp
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
           uri: URI::Generic,
+          trigger_character: T.nilable(String),
         ).void
       end
-      def initialize(response_builder, global_state, node_context, typechecker_enabled, dispatcher, uri) # rubocop:disable Metrics/ParameterLists
+      def initialize( # rubocop:disable Metrics/ParameterLists
+        response_builder,
+        global_state,
+        node_context,
+        typechecker_enabled,
+        dispatcher,
+        uri,
+        trigger_character
+      )
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
         @uri = uri
+        @trigger_character = trigger_character
 
         dispatcher.register(
           self,
@@ -42,7 +53,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 @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -63,7 +74,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 @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -107,7 +118,7 @@ module RubyLsp
         when "require_relative"
           complete_require_relative(node)
         else
-          complete_self_receiver_method(node, name) if !@typechecker_enabled && self_receiver?(node)
+          complete_methods(node, name) unless @typechecker_enabled
         end
       end
 
@@ -158,7 +169,7 @@ module RubyLsp
           name.delete_suffix("::")
         else
           *namespace, incomplete_name = name.split("::")
-          T.must(namespace).join("::")
+          namespace.join("::")
         end
 
         nesting = @node_context.nesting
@@ -192,7 +203,10 @@ module RubyLsp
 
       sig { params(name: String, location: Prism::Location).void }
       def handle_instance_variable_completion(name, location)
-        @index.instance_variable_completion_candidates(name, @node_context.fully_qualified_name).each do |entry|
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        @index.instance_variable_completion_candidates(name, type).each do |entry|
           variable_name = entry.name
 
           @response_builder << Interface::CompletionItem.new(
@@ -257,20 +271,45 @@ module RubyLsp
       end
 
       sig { params(node: Prism::CallNode, name: String).void }
-      def complete_self_receiver_method(node, name)
-        receiver_entries = @index[@node_context.fully_qualified_name]
-        return unless receiver_entries
+      def complete_methods(node, name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        # When the trigger character is a dot, Prism matches the name of the call node to whatever is next in the source
+        # code, leading to us searching for the wrong name. What we want to do instead is show every available method
+        # when dot is pressed
+        method_name = @trigger_character == "." ? nil : name
+
+        range = if method_name
+          range_from_location(T.must(node.message_loc))
+        else
+          loc = T.must(node.call_operator_loc)
+          Interface::Range.new(
+            start: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+            end: Interface::Position.new(line: loc.start_line - 1, character: loc.start_column + 1),
+          )
+        end
 
-        receiver = T.must(receiver_entries.first)
+        @index.method_completion_candidates(method_name, type).each do |entry|
+          entry_name = entry.name
 
-        @index.method_completion_candidates(name, receiver.name).each do |entry|
-          @response_builder << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
+          @response_builder << Interface::CompletionItem.new(
+            label: entry_name,
+            filter_text: entry_name,
+            text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
+            kind: Constant::CompletionItemKind::METHOD,
+            data: {
+              owner_name: entry.owner&.name,
+            },
+          )
         end
+      rescue RubyIndexer::Index::NonExistingNamespaceError
+        # We have not indexed this namespace, so we can't provide any completions
       end
 
       sig do
         params(
-          entry: RubyIndexer::Entry::Member,
+          entry: T.any(RubyIndexer::Entry::Member, RubyIndexer::Entry::MethodAlias),
           node: Prism::CallNode,
         ).returns(Interface::CompletionItem)
       end
@@ -283,7 +322,7 @@ module RubyLsp
           text_edit: Interface::TextEdit.new(range: range_from_location(T.must(node.message_loc)), new_text: name),
           kind: Constant::CompletionItemKind::METHOD,
           label_details: Interface::CompletionItemLabelDetails.new(
-            detail: "(#{entry.parameters.map(&:decorated_name).join(", ")})",
+            detail: entry.decorated_parameters,
             description: entry.file_name,
           ),
           documentation: Interface::MarkupContent.new(

data/lib/ruby_lsp/listeners/definition.rb

@@ -23,6 +23,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @uri = uri
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
@@ -48,7 +49,7 @@ module RubyLsp
         message = node.message
         return unless message
 
-        handle_method_definition(message, self_receiver?(node))
+        handle_method_definition(message, @type_inferrer.infer_receiver_type(@node_context))
       end
 
       sig { params(node: Prism::StringNode).void }
@@ -70,7 +71,7 @@ module RubyLsp
         value = expression.value
         return unless value
 
-        handle_method_definition(value, false)
+        handle_method_definition(value, nil)
       end
 
       sig { params(node: Prism::ConstantPathNode).void }
@@ -123,7 +124,10 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_definition(name)
-        entries = @index.resolve_instance_variable(name, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_instance_variable(name, type)
         return unless entries
 
         entries.each do |entry|
@@ -141,10 +145,10 @@ module RubyLsp
         # If by any chance we haven't indexed the owner, then there's no way to find the right declaration
       end
 
-      sig { params(message: String, self_receiver: T::Boolean).void }
-      def handle_method_definition(message, self_receiver)
-        methods = if self_receiver
-          @index.resolve_method(message, @node_context.fully_qualified_name)
+      sig { params(message: String, receiver_type: T.nilable(String)).void }
+      def handle_method_definition(message, receiver_type)
+        methods = if receiver_type
+          @index.resolve_method(message, receiver_type)
         else
           # If the method doesn't have a receiver, then we provide a few candidates to jump to
           # But we don't want to provide too many candidates, as it can be overwhelming

data/lib/ruby_lsp/listeners/hover.rb

@@ -47,6 +47,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @path = T.let(uri.to_standardized_path, T.nilable(String))
         @node_context = node_context
         @typechecker_enabled = typechecker_enabled
@@ -78,14 +79,14 @@ module RubyLsp
 
       sig { params(node: Prism::ConstantWriteNode).void }
       def on_constant_write_node_enter(node)
-        return if @global_state.typechecker
+        return if @global_state.has_type_checker
 
         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 @global_state.typechecker
+        return if @global_state.has_type_checker
 
         name = constant_name(node)
         return if name.nil?
@@ -95,8 +96,6 @@ module RubyLsp
 
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
-        return unless self_receiver?(node)
-
         if @path && File.basename(@path) == GEMFILE_NAME && node.name == :gem
           generate_gem_hover(node)
           return
@@ -107,10 +106,15 @@ module RubyLsp
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type)
         return unless methods
 
-        categorized_markdown_from_index_entries(message, methods).each do |category, content|
+        title = "#{message}#{T.must(methods.first).decorated_parameters}"
+
+        categorized_markdown_from_index_entries(title, methods).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end
@@ -149,7 +153,10 @@ module RubyLsp
 
       sig { params(name: String).void }
       def handle_instance_variable_hover(name)
-        entries = @index.resolve_instance_variable(name, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        entries = @index.resolve_instance_variable(name, type)
         return unless entries
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -21,6 +21,7 @@ module RubyLsp
         @response_builder = response_builder
         @global_state = global_state
         @index = T.let(global_state.index, RubyIndexer::Index)
+        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
         @node_context = node_context
         dispatcher.register(self, :on_call_node_enter)
       end
@@ -28,12 +29,14 @@ module RubyLsp
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         return if @typechecker_enabled
-        return unless self_receiver?(node)
 
         message = node.message
         return unless message
 
-        methods = @index.resolve_method(message, @node_context.fully_qualified_name)
+        type = @type_inferrer.infer_receiver_type(@node_context)
+        return unless type
+
+        methods = @index.resolve_method(message, type)
         return unless methods
 
         target_method = methods.first

data/lib/ruby_lsp/node_context.rb

@@ -16,19 +16,24 @@ module RubyLsp
     sig { returns(T.nilable(Prism::CallNode)) }
     attr_reader :call_node
 
+    sig { returns(T.nilable(String)) }
+    attr_reader :surrounding_method
+
     sig do
       params(
         node: T.nilable(Prism::Node),
         parent: T.nilable(Prism::Node),
         nesting: T::Array[String],
         call_node: T.nilable(Prism::CallNode),
+        surrounding_method: T.nilable(String),
       ).void
     end
-    def initialize(node, parent, nesting, call_node)
+    def initialize(node, parent, nesting, call_node, surrounding_method)
       @node = node
       @parent = parent
       @nesting = nesting
       @call_node = call_node
+      @surrounding_method = surrounding_method
     end
 
     sig { returns(String) }

data/lib/ruby_lsp/requests/completion.rb

@@ -36,7 +36,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'", ":", "@"],
+            trigger_characters: ["/", "\"", "'", ":", "@", "."],
             completion_item: {
               labelDetailsSupport: true,
             },
@@ -48,18 +48,18 @@ module RubyLsp
         params(
           document: Document,
           global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
+          params: T::Hash[Symbol, T.untyped],
           typechecker_enabled: T::Boolean,
           dispatcher: Prism::Dispatcher,
         ).void
       end
-      def initialize(document, global_state, position, typechecker_enabled, dispatcher)
+      def initialize(document, global_state, params, typechecker_enabled, dispatcher)
         super()
         @target = T.let(nil, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         # 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
+        char_position = document.create_scanner.find_char_position(params[:position]) - 1
         node_context = document.locate(
           document.tree,
           char_position,
@@ -87,6 +87,7 @@ module RubyLsp
           typechecker_enabled,
           dispatcher,
           document.uri,
+          params.dig(:context, :triggerCharacter),
         )
 
         Addon.addons.each do |addon|

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -56,8 +56,16 @@ module RubyLsp
           end
         end
 
+        first_entry = T.must(entries.first)
+
+        if first_entry.is_a?(RubyIndexer::Entry::Member)
+          detail = first_entry.decorated_parameters
+          label = "#{label}#{first_entry.decorated_parameters}"
+        end
+
         @item[:labelDetails] = Interface::CompletionItemLabelDetails.new(
           description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
+          detail: detail,
         )
 
         @item[:documentation] = Interface::MarkupContent.new(

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -0,0 +1,88 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Prepare type hierarchy demo](../../prepare_type_hierarchy.gif)
+    #
+    # The [prepare type hierarchy
+    # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareTypeHierarchy)
+    # displays the list of ancestors (supertypes) and descendants (subtypes) for the selected type.
+    #
+    # Currently only supports supertypes due to a limitation of the index.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Foo; end
+    # class Bar < Foo; end
+    #
+    # puts Bar # <-- right click on `Bar` and select "Show Type Hierarchy"
+    # ```
+    class PrepareTypeHierarchy < Request
+      extend T::Sig
+
+      include Support::Common
+
+      class << self
+        extend T::Sig
+
+        sig { returns(Interface::TypeHierarchyOptions) }
+        def provider
+          Interface::TypeHierarchyOptions.new
+        end
+      end
+
+      sig do
+        params(
+          document: Document,
+          index: RubyIndexer::Index,
+          position: T::Hash[Symbol, T.untyped],
+        ).void
+      end
+      def initialize(document, index, position)
+        super()
+
+        @document = document
+        @index = index
+        @position = position
+      end
+
+      sig { override.returns(T.nilable(T::Array[Interface::TypeHierarchyItem])) }
+      def perform
+        context = @document.locate_node(
+          @position,
+          node_types: [
+            Prism::ConstantReadNode,
+            Prism::ConstantWriteNode,
+            Prism::ConstantPathNode,
+          ],
+        )
+
+        node = context.node
+        parent = context.parent
+        return unless node && parent
+
+        target = determine_target(node, parent, @position)
+        entries = @index.resolve(target.slice, context.nesting)
+        return unless entries
+
+        # While the spec allows for multiple entries, VSCode seems to only support one
+        # We'll just return the first one for now
+        first_entry = T.must(entries.first)
+
+        range = range_from_location(first_entry.location)
+
+        [
+          Interface::TypeHierarchyItem.new(
+            name: first_entry.name,
+            kind: kind_for_entry(first_entry),
+            uri: URI::Generic.from_path(path: first_entry.file_path).to_s,
+            range: range,
+            selection_range: range,
+          ),
+        ]
+      end
+    end
+  end
+end

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

@@ -26,7 +26,7 @@ module RubyLsp
           )
         end
 
-        sig { params(location: Prism::Location).returns(Interface::Range) }
+        sig { params(location: T.any(Prism::Location, RubyIndexer::Location)).returns(Interface::Range) }
         def range_from_location(location)
           Interface::Range.new(
             start: Interface::Position.new(
@@ -186,6 +186,24 @@ module RubyLsp
             current = current.parent
           end
         end
+
+        sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
+        def kind_for_entry(entry)
+          case entry
+          when RubyIndexer::Entry::Class
+            Constant::SymbolKind::CLASS
+          when RubyIndexer::Entry::Module
+            Constant::SymbolKind::NAMESPACE
+          when RubyIndexer::Entry::Constant
+            Constant::SymbolKind::CONSTANT
+          when RubyIndexer::Entry::Method
+            entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
+          when RubyIndexer::Entry::Accessor
+            Constant::SymbolKind::PROPERTY
+          when RubyIndexer::Entry::InstanceVariable
+            Constant::SymbolKind::FIELD
+          end
+        end
       end
     end
   end

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

@@ -42,7 +42,7 @@ module RubyLsp
         def to_lsp_code_actions
           code_actions = []
 
-          code_actions << autocorrect_action if @offense.correctable?
+          code_actions << autocorrect_action if correctable?
           code_actions << disable_line_action
 
           code_actions
@@ -70,7 +70,7 @@ module RubyLsp
               ),
             ),
             data: {
-              correctable: @offense.correctable?,
+              correctable: correctable?,
               code_actions: to_lsp_code_actions,
             },
           )
@@ -81,7 +81,7 @@ module RubyLsp
         sig { returns(String) }
         def message
           message  = @offense.message
-          message += "\n\nThis offense is not auto-correctable.\n" unless @offense.correctable?
+          message += "\n\nThis offense is not auto-correctable.\n" unless correctable?
           message
         end
 
@@ -115,7 +115,7 @@ module RubyLsp
                     uri: @uri.to_s,
                     version: nil,
                   ),
-                  edits: @offense.correctable? ? offense_replacements : [],
+                  edits: correctable? ? offense_replacements : [],
                 ),
               ],
             ),
@@ -193,6 +193,14 @@ module RubyLsp
             line.length
           end
         end
+
+        # When `RuboCop::LSP.enable` is called, contextual autocorrect will not offer itself
+        # as `correctable?` to prevent annoying changes while typing. Instead check if
+        # a corrector is present. If it is, then that means some code transformation can be applied.
+        sig { returns(T::Boolean) }
+        def correctable?
+          !@offense.corrector.nil?
+        end
       end
     end
   end

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -0,0 +1,91 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Type hierarchy supertypes demo](../../type_hierarchy_supertypes.gif)
+    #
+    # The [type hierarchy supertypes
+    # request](https://microsoft.github.io/language-server-protocol/specification#typeHierarchy_supertypes)
+    # displays the list of ancestors (supertypes) for the selected type.
+    #
+    # # Example
+    #
+    # ```ruby
+    # class Foo; end
+    # class Bar < Foo; end
+    #
+    # puts Bar # <-- right click on `Bar` and select "Show Type Hierarchy"
+    # ```
+    class TypeHierarchySupertypes < Request
+      extend T::Sig
+
+      include Support::Common
+
+      sig { params(index: RubyIndexer::Index, item: T::Hash[Symbol, T.untyped]).void }
+      def initialize(index, item)
+        super()
+
+        @index = index
+        @item = item
+      end
+
+      sig { override.returns(T.nilable(T::Array[Interface::TypeHierarchyItem])) }
+      def perform
+        name = @item[:name]
+        entries = @index[name]
+
+        parents = T.let(Set.new, T::Set[RubyIndexer::Entry::Namespace])
+        return unless entries&.any?
+
+        entries.each do |entry|
+          next unless entry.is_a?(RubyIndexer::Entry::Namespace)
+
+          if entry.is_a?(RubyIndexer::Entry::Class)
+            parent_class_name = entry.parent_class
+            if parent_class_name
+              resolved_parent_entries = @index.resolve(parent_class_name, entry.nesting)
+              resolved_parent_entries&.each do |entry|
+                next unless entry.is_a?(RubyIndexer::Entry::Class)
+
+                parents << entry
+              end
+            end
+          end
+
+          entry.mixin_operations.each do |mixin_operation|
+            next if mixin_operation.is_a?(RubyIndexer::Entry::Extend)
+
+            mixin_name = mixin_operation.module_name
+            resolved_mixin_entries = @index.resolve(mixin_name, entry.nesting)
+            next unless resolved_mixin_entries
+
+            resolved_mixin_entries.each do |mixin_entry|
+              next unless mixin_entry.is_a?(RubyIndexer::Entry::Module)
+
+              parents << mixin_entry
+            end
+          end
+        end
+
+        parents.map { |entry| hierarchy_item(entry) }
+      end
+
+      private
+
+      sig { params(entry: RubyIndexer::Entry).returns(Interface::TypeHierarchyItem) }
+      def hierarchy_item(entry)
+        range = range_from_location(entry.location)
+
+        Interface::TypeHierarchyItem.new(
+          name: entry.name,
+          kind: kind_for_entry(entry),
+          uri: URI::Generic.from_path(path: entry.file_path).to_s,
+          range: range,
+          selection_range: range,
+          detail: entry.file_name,
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -52,7 +52,7 @@ module RubyLsp
 
           Interface::WorkspaceSymbol.new(
             name: entry.name,
-            container_name: T.must(container).join("::"),
+            container_name: container.join("::"),
             kind: kind,
             location: Interface::Location.new(
               uri: URI::Generic.from_path(path: file_path).to_s,
@@ -64,26 +64,6 @@ module RubyLsp
           )
         end
       end
-
-      private
-
-      sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
-      def kind_for_entry(entry)
-        case entry
-        when RubyIndexer::Entry::Class
-          Constant::SymbolKind::CLASS
-        when RubyIndexer::Entry::Module
-          Constant::SymbolKind::NAMESPACE
-        when RubyIndexer::Entry::Constant
-          Constant::SymbolKind::CONSTANT
-        when RubyIndexer::Entry::Method
-          entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
-        when RubyIndexer::Entry::Accessor
-          Constant::SymbolKind::PROPERTY
-        when RubyIndexer::Entry::InstanceVariable
-          Constant::SymbolKind::FIELD
-        end
-      end
     end
   end
 end

data/lib/ruby_lsp/requests.rb

@@ -47,6 +47,8 @@ module RubyLsp
     autoload :ShowSyntaxTree, "ruby_lsp/requests/show_syntax_tree"
     autoload :WorkspaceSymbol, "ruby_lsp/requests/workspace_symbol"
     autoload :SignatureHelp, "ruby_lsp/requests/signature_help"
+    autoload :PrepareTypeHierarchy, "ruby_lsp/requests/prepare_type_hierarchy"
+    autoload :TypeHierarchySupertypes, "ruby_lsp/requests/type_hierarchy_supertypes"
 
     # :nodoc:
     module Support