ruby-lsp 0.16.7 → 0.17.0

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -24,6 +24,7 @@ module RubyLsp
     class CodeActionResolve < Request
       extend T::Sig
       NEW_VARIABLE_NAME = "new_variable"
+      NEW_METHOD_NAME = "new_method"
 
       class CodeActionError < StandardError; end
 
@@ -31,6 +32,7 @@ module RubyLsp
         enums do
           EmptySelection = new
           InvalidTargetRange = new
+          UnknownCodeAction = new
         end
       end
 
@@ -43,6 +45,18 @@ module RubyLsp
 
       sig { override.returns(T.any(Interface::CodeAction, Error)) }
       def perform
+        case @code_action[:title]
+        when CodeActions::EXTRACT_TO_VARIABLE_TITLE
+          refactor_variable
+        when CodeActions::EXTRACT_TO_METHOD_TITLE
+          refactor_method
+        else
+          Error::UnknownCodeAction
+        end
+      end
+
+      sig { returns(T.any(Interface::CodeAction, Error)) }
+      def refactor_variable
         return Error::EmptySelection if @document.source.empty?
 
         source_range = @code_action.dig(:data, :range)
@@ -54,9 +68,11 @@ module RubyLsp
         extracted_source = T.must(@document.source[start_index...end_index])
 
         # Find the closest statements node, so that we place the refactor in a valid position
-        closest_statements, parent_statements = @document
+        node_context = @document
           .locate(@document.tree, start_index, node_types: [Prism::StatementsNode, Prism::BlockNode])
 
+        closest_statements = node_context.node
+        parent_statements = node_context.parent
         return Error::InvalidTargetRange if closest_statements.nil? || closest_statements.child_nodes.compact.empty?
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
@@ -117,7 +133,7 @@ module RubyLsp
         end
 
         Interface::CodeAction.new(
-          title: "Refactor: Extract Variable",
+          title: CodeActions::EXTRACT_TO_VARIABLE_TITLE,
           edit: Interface::WorkspaceEdit.new(
             document_changes: [
               Interface::TextDocumentEdit.new(
@@ -135,6 +151,61 @@ module RubyLsp
         )
       end
 
+      sig { returns(T.any(Interface::CodeAction, Error)) }
+      def refactor_method
+        return Error::EmptySelection if @document.source.empty?
+
+        source_range = @code_action.dig(:data, :range)
+        return Error::EmptySelection if source_range[:start] == source_range[:end]
+
+        scanner = @document.create_scanner
+        start_index = scanner.find_char_position(source_range[:start])
+        end_index = scanner.find_char_position(source_range[:end])
+        extracted_source = T.must(@document.source[start_index...end_index])
+
+        # Find the closest method declaration node, so that we place the refactor in a valid position
+        node_context = @document.locate(@document.tree, start_index, node_types: [Prism::DefNode])
+        closest_def = T.cast(node_context.node, Prism::DefNode)
+        return Error::InvalidTargetRange if closest_def.nil?
+
+        end_keyword_loc = closest_def.end_keyword_loc
+        return Error::InvalidTargetRange if end_keyword_loc.nil?
+
+        end_line = end_keyword_loc.end_line - 1
+        character = end_keyword_loc.end_column
+        indentation = " " * end_keyword_loc.start_column
+        target_range = {
+          start: { line: end_line, character: character },
+          end: { line: end_line, character: character },
+        }
+
+        new_method_source = <<~RUBY.chomp
+
+
+          #{indentation}def #{NEW_METHOD_NAME}
+          #{indentation}  #{extracted_source}
+          #{indentation}end
+        RUBY
+
+        Interface::CodeAction.new(
+          title: CodeActions::EXTRACT_TO_METHOD_TITLE,
+          edit: Interface::WorkspaceEdit.new(
+            document_changes: [
+              Interface::TextDocumentEdit.new(
+                text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
+                  uri: @code_action.dig(:data, :uri),
+                  version: nil,
+                ),
+                edits: [
+                  create_text_edit(target_range, new_method_source),
+                  create_text_edit(source_range, NEW_METHOD_NAME),
+                ],
+              ),
+            ],
+          ),
+        )
+      end
+
       private
 
       sig { params(range: T::Hash[Symbol, T.untyped], new_text: String).returns(Interface::TextEdit) }

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,25 @@ 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,
+          ],
         )
 
+        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
@@ -71,13 +86,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/workspace_symbol.rb

@@ -39,7 +39,7 @@ module RubyLsp
           next if @global_state.typechecker && not_in_dependencies?(file_path)
 
           # 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 +79,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)
@@ -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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.16.7
+  version: 0.17.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-22 00:00:00.000000000 Z
+date: 2024-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -90,6 +90,7 @@ files:
 - 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/test_case.rb
@@ -111,6 +112,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