ruby-lsp 0.16.7 → 0.17.3

data/lib/ruby_lsp/requests/code_actions.rb

@@ -19,6 +19,9 @@ module RubyLsp
     class CodeActions < Request
       extend T::Sig
 
+      EXTRACT_TO_VARIABLE_TITLE = "Refactor: Extract Variable"
+      EXTRACT_TO_METHOD_TITLE = "Refactor: Extract Method"
+
       class << self
         extend T::Sig
 
@@ -52,22 +55,20 @@ module RubyLsp
         end
 
         # Only add refactor actions if there's a non empty selection in the editor
-        code_actions << refactor_code_action(@range, @uri) unless @range.dig(:start) == @range.dig(:end)
-        code_actions
-      end
-
-      private
+        unless @range.dig(:start) == @range.dig(:end)
+          code_actions << Interface::CodeAction.new(
+            title: EXTRACT_TO_VARIABLE_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+            data: { range: @range, uri: @uri.to_s },
+          )
+          code_actions << Interface::CodeAction.new(
+            title: EXTRACT_TO_METHOD_TITLE,
+            kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
+            data: { range: @range, uri: @uri.to_s },
+          )
+        end
 
-      sig { params(range: T::Hash[Symbol, T.untyped], uri: URI::Generic).returns(Interface::CodeAction) }
-      def refactor_code_action(range, uri)
-        Interface::CodeAction.new(
-          title: "Refactor: Extract Variable",
-          kind: Constant::CodeActionKind::REFACTOR_EXTRACT,
-          data: {
-            range: range,
-            uri: uri.to_s,
-          },
-        )
+        code_actions
       end
     end
   end

data/lib/ruby_lsp/requests/completion.rb

@@ -17,6 +17,7 @@ module RubyLsp
     # - Constants
     # - Require paths
     # - Methods invoked on self only
+    # - Instance variables
     #
     # # Example
     #
@@ -35,7 +36,7 @@ module RubyLsp
         def provider
           Interface::CompletionOptions.new(
             resolve_provider: true,
-            trigger_characters: ["/", "\"", "'", ":"],
+            trigger_characters: ["/", "\"", "'", ":", "@"],
             completion_item: {
               labelDetailsSupport: true,
             },
@@ -59,10 +60,20 @@ module RubyLsp
         # 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
-        matched, parent, nesting = document.locate(
+        node_context = document.locate(
           document.tree,
           char_position,
-          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode],
+          node_types: [
+            Prism::CallNode,
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
+          ],
         )
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem].new,
@@ -72,27 +83,24 @@ module RubyLsp
         Listeners::Completion.new(
           @response_builder,
           global_state,
-          nesting,
+          node_context,
           typechecker_enabled,
           dispatcher,
           document.uri,
         )
 
         Addon.addons.each do |addon|
-          addon.create_completion_listener(@response_builder, nesting, dispatcher, document.uri)
+          addon.create_completion_listener(@response_builder, node_context, dispatcher, document.uri)
         end
 
+        matched = node_context.node
+        parent = node_context.parent
         return unless matched && parent
 
-        @target = case matched
-        when Prism::CallNode
+        @target = if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
+          parent
+        else
           matched
-        when Prism::ConstantReadNode, Prism::ConstantPathNode
-          if parent.is_a?(Prism::ConstantPathNode) && matched.is_a?(Prism::ConstantReadNode)
-            parent
-          else
-            matched
-          end
         end
       end
 

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -47,6 +47,15 @@ module RubyLsp
         label = @item[:label]
         entries = @index[label] || []
 
+        owner_name = @item.dig(:data, :owner_name)
+
+        if owner_name
+          entries = entries.select do |entry|
+            (entry.is_a?(RubyIndexer::Entry::Member) || entry.is_a?(RubyIndexer::Entry::InstanceVariable)) &&
+              entry.owner&.name == owner_name
+          end
+        end
+
         @item[:labelDetails] = Interface::CompletionItemLabelDetails.new(
           description: entries.take(MAX_DOCUMENTATION_ENTRIES).map(&:file_name).join(","),
         )

data/lib/ruby_lsp/requests/definition.rb

@@ -17,7 +17,8 @@ module RubyLsp
     # - Modules
     # - Constants
     # - Require paths
-    # - Methods invoked on self only
+    # - Methods invoked on self only and on receivers where the type is unknown
+    # - Instance variables
     #
     # # Example
     #
@@ -46,11 +47,27 @@ module RubyLsp
         )
         @dispatcher = dispatcher
 
-        target, parent, nesting = document.locate_node(
+        node_context = document.locate_node(
           position,
-          node_types: [Prism::CallNode, Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::BlockArgumentNode],
+          node_types: [
+            Prism::CallNode,
+            Prism::ConstantReadNode,
+            Prism::ConstantPathNode,
+            Prism::BlockArgumentNode,
+            Prism::InstanceVariableReadNode,
+            Prism::InstanceVariableAndWriteNode,
+            Prism::InstanceVariableOperatorWriteNode,
+            Prism::InstanceVariableOrWriteNode,
+            Prism::InstanceVariableTargetNode,
+            Prism::InstanceVariableWriteNode,
+            Prism::SymbolNode,
+            Prism::StringNode,
+          ],
         )
 
+        target = node_context.node
+        parent = node_context.parent
+
         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
@@ -64,6 +81,9 @@ module RubyLsp
           # 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
+        # For methods with block arguments using symbol-to-proc
+        elsif target.is_a?(Prism::SymbolNode) && parent.is_a?(Prism::BlockArgumentNode)
+          target = parent
         end
 
         if target
@@ -71,13 +91,13 @@ module RubyLsp
             @response_builder,
             global_state,
             document.uri,
-            nesting,
+            node_context,
             dispatcher,
             typechecker_enabled,
           )
 
           Addon.addons.each do |addon|
-            addon.create_definition_listener(@response_builder, document.uri, nesting, dispatcher)
+            addon.create_definition_listener(@response_builder, document.uri, node_context, dispatcher)
           end
         end
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -36,12 +36,12 @@ module RubyLsp
       end
       def initialize(document, position, dispatcher)
         super()
-        target, parent = document.locate_node(position)
+        node_context = document.locate_node(position)
         @response_builder = T.let(
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
           ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
         )
-        Listeners::DocumentHighlight.new(@response_builder, target, parent, dispatcher)
+        Listeners::DocumentHighlight.new(@response_builder, node_context.node, node_context.parent, dispatcher)
       end
 
       sig { override.returns(T::Array[Interface::DocumentHighlight]) }

data/lib/ruby_lsp/requests/hover.rb

@@ -41,10 +41,9 @@ module RubyLsp
       end
       def initialize(document, global_state, position, dispatcher, typechecker_enabled)
         super()
-        target, parent, nesting = document.locate_node(
-          position,
-          node_types: Listeners::Hover::ALLOWED_TARGETS,
-        )
+        node_context = document.locate_node(position, node_types: Listeners::Hover::ALLOWED_TARGETS)
+        target = node_context.node
+        parent = node_context.parent
 
         if (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
             !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
@@ -66,9 +65,9 @@ module RubyLsp
         @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)
+        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled)
         Addon.addons.each do |addon|
-          addon.create_hover_listener(@response_builder, nesting, dispatcher)
+          addon.create_hover_listener(@response_builder, node_context, dispatcher)
         end
 
         @dispatcher = dispatcher

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -213,12 +213,13 @@ module RubyLsp
       sig { void }
       def auto_indent_after_end_keyword
         current_line = @lines[@position[:line]]
-        return unless current_line&.strip == "end"
+        return unless current_line && current_line.strip == "end"
 
-        target, _parent, _nesting = @document.locate_node({
+        node_context = @document.locate_node({
           line: @position[:line],
           character: @position[:character] - 1,
         })
+        target = node_context.node
 
         statements = case target
         when Prism::IfNode, Prism::UnlessNode, Prism::ForNode, Prism::WhileNode, Prism::UntilNode
@@ -226,11 +227,14 @@ module RubyLsp
         end
         return unless statements
 
+        current_indentation = find_indentation(current_line)
         statements.body.each do |node|
           loc = node.location
-          next unless loc.start_column == @indentation
+          next unless loc.start_column == current_indentation
 
-          add_edit_with_text("  ", { line: loc.start_line - 1, character: 0 })
+          (loc.start_line..loc.end_line).each do |line|
+            add_edit_with_text("  ", { line: line - 1, character: 0 })
+          end
         end
 
         move_cursor_to(@position[:line], @position[:character])

data/lib/ruby_lsp/requests/signature_help.rb

@@ -51,17 +51,17 @@ module RubyLsp
       end
       def initialize(document, global_state, position, context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
         super()
-        target, parent, nesting = document.locate_node(
+        node_context = document.locate_node(
           { line: position[:line], character: position[:character] },
           node_types: [Prism::CallNode],
         )
 
-        target = adjust_for_nested_target(target, parent, position)
+        target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, global_state, nesting, dispatcher, typechecker_enabled)
+        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, typechecker_enabled)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

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

@@ -50,12 +50,12 @@ module RubyLsp
           params(
             node: Prism::Node,
             title: String,
-            command_name: T.nilable(String),
+            command_name: 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: nil, arguments: nil, data: nil)
+        def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_node(node)
 
           Interface::CodeLens.new(
@@ -155,7 +155,8 @@ module RubyLsp
         end
         def constant_name(node)
           node.full_name
-        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError
+        rescue Prism::ConstantPathNode::DynamicPartsInConstantPathError,
+               Prism::ConstantPathNode::MissingNodesInConstantPathError
           nil
         end
 

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

@@ -19,6 +19,16 @@ module RubyLsp
           T::Hash[Symbol, Integer],
         )
 
+        ENHANCED_DOC_URL = T.let(
+          begin
+            gem("rubocop", ">= 1.64.0")
+            true
+          rescue LoadError
+            false
+          end,
+          T::Boolean,
+        )
+
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
         sig { params(document: Document, offense: RuboCop::Cop::Offense, uri: URI::Generic).void }
@@ -38,8 +48,8 @@ module RubyLsp
           code_actions
         end
 
-        sig { returns(Interface::Diagnostic) }
-        def to_lsp_diagnostic
+        sig { params(config: RuboCop::Config).returns(Interface::Diagnostic) }
+        def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
           highlighted = @offense.highlighted_area
@@ -47,7 +57,7 @@ module RubyLsp
             message: message,
             source: "RuboCop",
             code: @offense.cop_name,
-            code_description: code_description,
+            code_description: code_description(config),
             severity: severity,
             range: Interface::Range.new(
               start: Interface::Position.new(
@@ -80,9 +90,16 @@ module RubyLsp
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { returns(T.nilable(Interface::CodeDescription)) }
-        def code_description
-          doc_url = RuboCopRunner.find_cop_by_name(@offense.cop_name)&.documentation_url
+        sig { params(config: RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        def code_description(config)
+          cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
+          return unless cop
+
+          doc_url = if ENHANCED_DOC_URL
+            cop.documentation_url(config)
+          else
+            cop.documentation_url
+          end
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 

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

@@ -38,7 +38,11 @@ module RubyLsp
           @diagnostic_runner.run(filename, document.source)
 
           @diagnostic_runner.offenses.map do |offense|
-            Support::RuboCopDiagnostic.new(document, offense, uri).to_lsp_diagnostic
+            Support::RuboCopDiagnostic.new(
+              document,
+              offense,
+              uri,
+            ).to_lsp_diagnostic(@diagnostic_runner.config_for_working_directory)
           end
         end
       end

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

@@ -50,6 +50,9 @@ module RubyLsp
         sig { returns(T::Array[RuboCop::Cop::Offense]) }
         attr_reader :offenses
 
+        sig { returns(::RuboCop::Config) }
+        attr_reader :config_for_working_directory
+
         DEFAULT_ARGS = T.let(
           [
             "--stderr", # Print any output to stderr so that our stdout does not get polluted
@@ -78,6 +81,7 @@ module RubyLsp
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
           config_store = ::RuboCop::ConfigStore.new
+          @config_for_working_directory = T.let(config_store.for_pwd, ::RuboCop::Config)
 
           super(rubocop_options, config_store)
         end

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -33,13 +33,14 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
-          # If the project is using Sorbet, we let Sorbet handle symbols defined inside the project itself and RBIs, but
-          # we still return entries defined in gems to allow developers to jump directly to the source
           file_path = entry.file_path
-          next if @global_state.typechecker && not_in_dependencies?(file_path)
+
+          # We only show symbols declared in the workspace
+          in_dependencies = !not_in_dependencies?(file_path)
+          next if in_dependencies
 
           # We should never show private symbols when searching the entire workspace
-          next if entry.visibility == :private
+          next if entry.private?
 
           kind = kind_for_entry(entry)
           loc = entry.location
@@ -79,6 +80,8 @@ module RubyLsp
           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

data/lib/ruby_lsp/server.rb

@@ -104,7 +104,7 @@ module RubyLsp
           ),
         )
 
-        $stderr.puts(errored_addons.map(&:backtraces).join("\n\n"))
+        $stderr.puts(errored_addons.map(&:errors_details).join("\n\n"))
       end
     end
 
@@ -134,7 +134,7 @@ module RubyLsp
       when Hash
         # If the configuration is already a hash, merge it with a default value of `true`. That way clients don't have
         # to opt-in to every single feature
-        Hash.new(true).merge!(configured_features)
+        Hash.new(true).merge!(configured_features.transform_keys(&:to_s))
       else
         # If no configuration was passed by the client, just enable every feature
         Hash.new(true)
@@ -175,7 +175,7 @@ module RubyLsp
           completion_provider: completion_provider,
           code_lens_provider: code_lens_provider,
           definition_provider: enabled_features["definition"],
-          workspace_symbol_provider: enabled_features["workspaceSymbol"],
+          workspace_symbol_provider: enabled_features["workspaceSymbol"] && !@global_state.typechecker,
           signature_help_provider: signature_help_provider,
         ),
         serverInfo: {
@@ -498,6 +498,13 @@ module RubyLsp
           ),
         )
         raise Requests::CodeActionResolve::CodeActionError
+      when Requests::CodeActionResolve::Error::UnknownCodeAction
+        send_message(
+          Notification.window_show_error(
+            "Unknown code action",
+          ),
+        )
+        raise Requests::CodeActionResolve::CodeActionError
       else
         send_message(Result.new(id: message[:id], response: result))
       end
@@ -619,8 +626,7 @@ module RubyLsp
         when Constant::FileChangeType::CREATED
           index.index_single(indexable)
         when Constant::FileChangeType::CHANGED
-          index.delete(indexable)
-          index.index_single(indexable)
+          index.handle_change(indexable)
         when Constant::FileChangeType::DELETED
           index.delete(indexable)
         end
@@ -684,6 +690,17 @@ 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)

data/lib/ruby_lsp/test_helper.rb

@@ -21,6 +21,7 @@ module RubyLsp
       &block)
       server = RubyLsp::Server.new(test_mode: true)
       server.global_state.stubs(:typechecker).returns(false) if stub_no_typechecker
+      server.global_state.apply_options({})
 
       if source
         server.process_message({

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.16.7
+  version: 0.17.3
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-22 00:00:00.000000000 Z
+date: 2024-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -33,7 +33,7 @@ dependencies:
         version: 0.29.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: '0.31'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,27 @@ dependencies:
         version: 0.29.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: '0.31'
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -85,13 +105,16 @@ files:
 - lib/ruby_indexer/lib/ruby_indexer/indexable_path.rb
 - lib/ruby_indexer/lib/ruby_indexer/location.rb
 - lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb
+- lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb
 - lib/ruby_indexer/ruby_indexer.rb
 - lib/ruby_indexer/test/classes_and_modules_test.rb
 - lib/ruby_indexer/test/configuration_test.rb
 - lib/ruby_indexer/test/constant_test.rb
 - lib/ruby_indexer/test/index_test.rb
+- lib/ruby_indexer/test/instance_variables_test.rb
 - lib/ruby_indexer/test/method_test.rb
 - lib/ruby_indexer/test/prefix_tree_test.rb
+- lib/ruby_indexer/test/rbs_indexer_test.rb
 - lib/ruby_indexer/test/test_case.rb
 - lib/ruby_lsp/addon.rb
 - lib/ruby_lsp/base_server.rb
@@ -111,6 +134,7 @@ files:
 - lib/ruby_lsp/listeners/semantic_highlighting.rb
 - lib/ruby_lsp/listeners/signature_help.rb
 - lib/ruby_lsp/load_sorbet.rb
+- lib/ruby_lsp/node_context.rb
 - lib/ruby_lsp/parameter_scope.rb
 - lib/ruby_lsp/requests.rb
 - lib/ruby_lsp/requests/code_action_resolve.rb
@@ -178,7 +202,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: An opinionated language server for Ruby