ruby-lsp 0.17.3 → 0.17.4

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

data/lib/ruby_lsp/server.rb

@@ -68,6 +68,12 @@ module RubyLsp
         text_document_signature_help(message)
       when "textDocument/definition"
         text_document_definition(message)
+      when "textDocument/prepareTypeHierarchy"
+        text_document_prepare_type_hierarchy(message)
+      when "typeHierarchy/supertypes"
+        type_hierarchy_supertypes(message)
+      when "typeHierarchy/subtypes"
+        type_hierarchy_subtypes(message)
       when "workspace/didChangeWatchedFiles"
         workspace_did_change_watched_files(message)
       when "workspace/symbol"
@@ -76,6 +82,16 @@ module RubyLsp
         text_document_show_syntax_tree(message)
       when "rubyLsp/workspace/dependencies"
         workspace_dependencies(message)
+      when "rubyLsp/workspace/addons"
+        send_message(
+          Result.new(
+            id: message[:id],
+            response:
+              Addon.addons.map do |addon|
+                { name: addon.name, errored: addon.error? }
+              end,
+          ),
+        )
       when "$/cancelRequest"
         @mutex.synchronize { @cancelled_requests << message[:params][:id] }
       end
@@ -104,7 +120,7 @@ module RubyLsp
           ),
         )
 
-        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n"))
+        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n")) unless @test_mode
       end
     end
 
@@ -152,6 +168,7 @@ module RubyLsp
       inlay_hint_provider = Requests::InlayHints.provider if enabled_features["inlayHint"]
       completion_provider = Requests::Completion.provider if enabled_features["completion"]
       signature_help_provider = Requests::SignatureHelp.provider if enabled_features["signatureHelp"]
+      type_hierarchy_provider = Requests::PrepareTypeHierarchy.provider if enabled_features["typeHierarchy"]
 
       response = {
         capabilities: Interface::ServerCapabilities.new(
@@ -175,8 +192,12 @@ module RubyLsp
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
-          workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.typechecker,
+          workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.has_type_checker,
           signature_help_provider: signature_help_provider,
+          type_hierarchy_provider: type_hierarchy_provider,
+          experimental: {
+            addon_detection: true,
+          },
         ),
         serverInfo: {
           name: "Ruby LSP",
@@ -449,7 +470,7 @@ module RubyLsp
 
     sig { params(document: Document).returns(T::Boolean) }
     def typechecker_enabled?(document)
-      @global_state.typechecker && document.sorbet_sigil_is_true_or_higher
+      @global_state.has_type_checker && document.sorbet_sigil_is_true_or_higher
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -551,7 +572,7 @@ module RubyLsp
           response: Requests::Completion.new(
             document,
             @global_state,
-            params[:position],
+            params,
             typechecker_enabled?(document),
             dispatcher,
           ).perform,
@@ -660,6 +681,33 @@ module RubyLsp
       send_message(Result.new(id: message[:id], response: response))
     end
 
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def text_document_prepare_type_hierarchy(message)
+      params = message[:params]
+      response = Requests::PrepareTypeHierarchy.new(
+        @store.get(params.dig(:textDocument, :uri)),
+        @global_state.index,
+        params[:position],
+      ).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def type_hierarchy_supertypes(message)
+      response = Requests::TypeHierarchySupertypes.new(
+        @global_state.index,
+        message.dig(:params, :item),
+      ).perform
+      send_message(Result.new(id: message[:id], response: response))
+    end
+
+    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    def type_hierarchy_subtypes(message)
+      # TODO: implement subtypes
+      # The current index representation doesn't allow us to find the children of an entry.
+      send_message(Result.new(id: message[:id], response: nil))
+    end
+
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
     def workspace_dependencies(message)
       response = begin
@@ -690,23 +738,14 @@ module RubyLsp
 
     sig { params(config_hash: T::Hash[String, T.untyped]).void }
     def perform_initial_indexing(config_hash)
-      index_ruby_core
-      index_ruby_code(config_hash)
-    end
-
-    sig { void }
-    def index_ruby_core
-      RubyIndexer::RBSIndexer.new(@global_state.index).index_ruby_core
-    end
-
-    sig { params(config_hash: T::Hash[String, T.untyped]).void }
-    def index_ruby_code(config_hash)
       # The begin progress invocation happens during `initialize`, so that the notification is sent before we are
       # stuck indexing files
       RubyIndexer.configuration.apply_config(config_hash)
 
       Thread.new do
         begin
+          RubyIndexer::RBSIndexer.new(@global_state.index).index_ruby_core
+
           @global_state.index.index_all do |percentage|
             progress("indexing-progress", percentage)
             true

data/lib/ruby_lsp/test_helper.rb

@@ -20,7 +20,7 @@ module RubyLsp
     def with_server(source = nil, uri = Kernel.URI("file:///fake.rb"), stub_no_typechecker: false, load_addons: true,
       &block)
       server = RubyLsp::Server.new(test_mode: true)
-      server.global_state.stubs(:typechecker).returns(false) if stub_no_typechecker
+      server.global_state.stubs(:has_type_checker).returns(false) if stub_no_typechecker
       server.global_state.apply_options({})
 
       if source

data/lib/ruby_lsp/type_inferrer.rb

@@ -0,0 +1,86 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  # A minimalistic type checker to try to resolve types that can be inferred without requiring a type system or
+  # annotations
+  class TypeInferrer
+    extend T::Sig
+
+    sig { params(index: RubyIndexer::Index).void }
+    def initialize(index)
+      @index = index
+    end
+
+    sig { params(node_context: NodeContext).returns(T.nilable(String)) }
+    def infer_receiver_type(node_context)
+      node = node_context.node
+
+      case node
+      when Prism::CallNode
+        infer_receiver_for_call_node(node, node_context)
+      when Prism::InstanceVariableReadNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableWriteNode,
+        Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode, Prism::InstanceVariableTargetNode
+        nesting = node_context.nesting
+        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+        # inherits from Object
+        return "Object" if nesting.empty?
+
+        fully_qualified_name = node_context.fully_qualified_name
+        return fully_qualified_name if node_context.surrounding_method
+
+        "#{fully_qualified_name}::<Class:#{nesting.last}>"
+      end
+    end
+
+    private
+
+    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(String)) }
+    def infer_receiver_for_call_node(node, node_context)
+      receiver = node.receiver
+
+      case receiver
+      when Prism::SelfNode, nil
+        nesting = node_context.nesting
+        # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
+        # inherits from Object
+        return "Object" if nesting.empty?
+        return node_context.fully_qualified_name if node_context.surrounding_method
+
+        # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
+        # context
+        "#{nesting.join("::")}::<Class:#{nesting.last}>"
+      when Prism::ConstantPathNode, Prism::ConstantReadNode
+        # When the receiver is a constant reference, we have to try to resolve it to figure out the right
+        # receiver. But since the invocation is directly on the constant, that's the singleton context of that
+        # class/module
+        receiver_name = constant_name(receiver)
+        return unless receiver_name
+
+        resolved_receiver = @index.resolve(receiver_name, node_context.nesting)
+        name = resolved_receiver&.first&.name
+        return unless name
+
+        *parts, last = name.split("::")
+        return "#{last}::<Class:#{last}>" if parts.empty?
+
+        "#{parts.join("::")}::#{last}::<Class:#{last}>"
+      end
+    end
+
+    sig do
+      params(
+        node: T.any(
+          Prism::ConstantPathNode,
+          Prism::ConstantReadNode,
+        ),
+      ).returns(T.nilable(String))
+    end
+    def constant_name(node)
+      node.full_name
+    rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+           Prism::ConstantPathNode::MissingNodesInConstantPathError
+      nil
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.3
+  version: 0.17.4
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-11 00:00:00.000000000 Z
+date: 2024-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -152,6 +152,7 @@ files:
 - lib/ruby_lsp/requests/hover.rb
 - lib/ruby_lsp/requests/inlay_hints.rb
 - lib/ruby_lsp/requests/on_type_formatting.rb
+- lib/ruby_lsp/requests/prepare_type_hierarchy.rb
 - lib/ruby_lsp/requests/request.rb
 - lib/ruby_lsp/requests/selection_ranges.rb
 - lib/ruby_lsp/requests/semantic_highlighting.rb
@@ -167,6 +168,7 @@ files:
 - lib/ruby_lsp/requests/support/sorbet.rb
 - lib/ruby_lsp/requests/support/source_uri.rb
 - lib/ruby_lsp/requests/support/syntax_tree_formatter.rb
+- lib/ruby_lsp/requests/type_hierarchy_supertypes.rb
 - lib/ruby_lsp/requests/workspace_symbol.rb
 - lib/ruby_lsp/response_builders.rb
 - lib/ruby_lsp/response_builders/collection_response_builder.rb
@@ -180,6 +182,7 @@ files:
 - lib/ruby_lsp/setup_bundler.rb
 - lib/ruby_lsp/store.rb
 - lib/ruby_lsp/test_helper.rb
+- lib/ruby_lsp/type_inferrer.rb
 - lib/ruby_lsp/utils.rb
 homepage: https://github.com/Shopify/ruby-lsp
 licenses: