ruby-lsp 0.12.2 → 0.13.0

data/lib/ruby_lsp/requests/completion.rb

@@ -6,9 +6,14 @@ module RubyLsp
     # ![Completion demo](../../completion.gif)
     #
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
-    # suggests possible completions according to what the developer is typing. Currently, completion is support for
-    # - require paths
-    # - classes, modules and constant names
+    # suggests possible completions according to what the developer is typing.
+    #
+    # Currently supported targets:
+    # - Classes
+    # - Modules
+    # - Constants
+    # - Require paths
+    # - Methods invoked on self only
     #
     # # Example
     #
@@ -31,11 +36,10 @@ module RubyLsp
           index: RubyIndexer::Index,
           nesting: T::Array[String],
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(index, nesting, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      def initialize(index, nesting, dispatcher)
+        super(dispatcher)
         @_response = T.let([], ResponseType)
         @index = index
         @nesting = nesting
@@ -45,6 +49,7 @@ module RubyLsp
           :on_string_node_enter,
           :on_constant_path_node_enter,
           :on_constant_read_node_enter,
+          :on_call_node_enter,
         )
       end
 
@@ -118,17 +123,64 @@ module RubyLsp
         end
       end
 
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+        return unless self_receiver?(node)
+
+        name = node.message
+        return unless name
+
+        receiver_entries = @index[@nesting.join("::")]
+        return unless receiver_entries
+
+        receiver = T.must(receiver_entries.first)
+
+        @index.prefix_search(name).each do |entries|
+          entry = entries.find { |e| e.is_a?(RubyIndexer::Entry::Member) && e.owner&.name == receiver.name }
+          next unless entry
+
+          @_response << build_method_completion(T.cast(entry, RubyIndexer::Entry::Member), node)
+        end
+      end
+
       private
 
+      sig do
+        params(
+          entry: RubyIndexer::Entry::Member,
+          node: Prism::CallNode,
+        ).returns(Interface::CompletionItem)
+      end
+      def build_method_completion(entry, node)
+        name = entry.name
+        parameters = entry.parameters
+        new_text = parameters.empty? ? name : "#{name}(#{parameters.map(&:name).join(", ")})"
+
+        Interface::CompletionItem.new(
+          label: name,
+          filter_text: name,
+          text_edit: Interface::TextEdit.new(range: range_from_node(node), new_text: new_text),
+          kind: Constant::CompletionItemKind::METHOD,
+          label_details: Interface::CompletionItemLabelDetails.new(
+            description: entry.file_name,
+          ),
+          documentation: markdown_from_index_entries(name, entry),
+        )
+      end
+
       sig { params(label: String, node: Prism::StringNode).returns(Interface::CompletionItem) }
       def build_completion(label, node)
+        # We should use the content location as we only replace the content and not the delimiters of the string
+        loc = node.content_loc
+
         Interface::CompletionItem.new(
           label: label,
           text_edit: Interface::TextEdit.new(
-            range: range_from_node(node),
+            range: range_from_location(loc),
             new_text: label,
           ),
-          kind: Constant::CompletionItemKind::REFERENCE,
+          kind: Constant::CompletionItemKind::FILE,
         )
       end
 

data/lib/ruby_lsp/requests/definition.rb

@@ -9,7 +9,12 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_definition) jumps to the
     # definition of the symbol under the cursor.
     #
-    # Currently, only jumping to classes, modules and required files is supported.
+    # Currently supported targets:
+    # - Classes
+    # - Modules
+    # - Constants
+    # - Require paths
+    # - Methods invoked on self only
     #
     # # Example
     #
@@ -32,16 +37,15 @@ module RubyLsp
           nesting: T::Array[String],
           index: RubyIndexer::Index,
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(uri, nesting, index, dispatcher, message_queue)
+      def initialize(uri, nesting, index, dispatcher)
         @uri = uri
         @nesting = nesting
         @index = index
         @_response = T.let(nil, ResponseType)
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
 
         dispatcher.register(
           self,
@@ -53,7 +57,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(RubyLsp::Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_definition_listener(@uri, @nesting, @index, @dispatcher, @message_queue)
+        addon.create_definition_listener(@uri, @nesting, @index, @dispatcher)
       end
 
       sig { override.params(other: Listener[ResponseType]).returns(T.self_type) }
@@ -75,8 +79,52 @@ module RubyLsp
       sig { params(node: Prism::CallNode).void }
       def on_call_node_enter(node)
         message = node.name
-        return unless message == :require || message == :require_relative
 
+        if message == :require || message == :require_relative
+          handle_require_definition(node)
+        else
+          handle_method_definition(node)
+        end
+      end
+
+      sig { params(node: Prism::ConstantPathNode).void }
+      def on_constant_path_node_enter(node)
+        find_in_index(node.slice)
+      end
+
+      sig { params(node: Prism::ConstantReadNode).void }
+      def on_constant_read_node_enter(node)
+        find_in_index(node.slice)
+      end
+
+      private
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_method_definition(node)
+        return unless self_receiver?(node)
+
+        message = node.message
+        return unless message
+
+        target_method = @index.resolve_method(message, @nesting.join("::"))
+        return unless target_method
+
+        location = target_method.location
+        file_path = target_method.file_path
+        return if defined_in_gem?(file_path)
+
+        @_response = Interface::Location.new(
+          uri: URI::Generic.from_path(path: file_path).to_s,
+          range: Interface::Range.new(
+            start: Interface::Position.new(line: location.start_line - 1, character: location.start_column),
+            end: Interface::Position.new(line: location.end_line - 1, character: location.end_column),
+          ),
+        )
+      end
+
+      sig { params(node: Prism::CallNode).void }
+      def handle_require_definition(node)
+        message = node.name
         arguments = node.arguments
         return unless arguments
 
@@ -116,18 +164,6 @@ module RubyLsp
         end
       end
 
-      sig { params(node: Prism::ConstantPathNode).void }
-      def on_constant_path_node_enter(node)
-        find_in_index(node.slice)
-      end
-
-      sig { params(node: Prism::ConstantReadNode).void }
-      def on_constant_read_node_enter(node)
-        find_in_index(node.slice)
-      end
-
-      private
-
       sig { params(value: String).void }
       def find_in_index(value)
         entries = @index.resolve(value, @nesting)
@@ -138,23 +174,13 @@ module RubyLsp
         first_entry = T.must(entries.first)
         return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{value}"
 
-        bundle_path = begin
-          Bundler.bundle_path.to_s
-        rescue Bundler::GemfileNotFound
-          nil
-        end
-
         @_response = entries.filter_map do |entry|
           location = entry.location
           # If the project has Sorbet, then we only want to handle go to definition for constants defined in gems, as an
           # additional behavior on top of jumping to RBIs. Sorbet can already handle go to definition for all constants
           # in the project, even if the files are typed false
           file_path = entry.file_path
-          if DependencyDetector.instance.typechecker && bundle_path && !file_path.start_with?(bundle_path) &&
-              !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
-
-            next
-          end
+          next if defined_in_gem?(file_path)
 
           Interface::Location.new(
             uri: URI::Generic.from_path(path: file_path).to_s,

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -32,13 +32,8 @@ module RubyLsp
       def run
         # Running RuboCop is slow, so to avoid excessive runs we only do so if the file is syntactically valid
         return syntax_error_diagnostics if @document.syntax_error?
-
         return unless defined?(Support::RuboCopDiagnosticsRunner)
 
-        # Don't try to run RuboCop diagnostics for files outside the current working directory
-        path = @uri.to_standardized_path
-        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
-
         Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document).map!(&:to_lsp_diagnostic)
       end
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -97,7 +97,8 @@ module RubyLsp
           Prism::LocalVariableWriteNode,
           Prism::BlockParameterNode,
           Prism::RequiredParameterNode,
-          Prism::KeywordParameterNode,
+          Prism::RequiredKeywordParameterNode,
+          Prism::OptionalKeywordParameterNode,
           Prism::RestParameterNode,
           Prism::OptionalParameterNode,
           Prism::KeywordRestParameterNode,
@@ -113,11 +114,10 @@ module RubyLsp
           target: T.nilable(Prism::Node),
           parent: T.nilable(Prism::Node),
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(target, parent, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      def initialize(target, parent, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], T::Array[Interface::DocumentHighlight])
 
@@ -137,8 +137,9 @@ module RubyLsp
             Prism::ClassVariableReadNode, Prism::ClassVariableTargetNode, Prism::ClassVariableWriteNode,
             Prism::LocalVariableAndWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
             Prism::LocalVariableReadNode, Prism::LocalVariableTargetNode, Prism::LocalVariableWriteNode,
-            Prism::CallNode, Prism::BlockParameterNode, Prism::KeywordParameterNode, Prism::KeywordRestParameterNode,
-            Prism::OptionalParameterNode, Prism::RequiredParameterNode, Prism::RestParameterNode
+            Prism::CallNode, Prism::BlockParameterNode, Prism::RequiredKeywordParameterNode,
+            Prism::RequiredKeywordParameterNode, Prism::KeywordRestParameterNode, Prism::OptionalParameterNode,
+            Prism::RequiredParameterNode, Prism::RestParameterNode
             target
           end
 
@@ -171,7 +172,8 @@ module RubyLsp
             :on_constant_path_and_write_node_enter,
             :on_constant_path_operator_write_node_enter,
             :on_local_variable_write_node_enter,
-            :on_keyword_parameter_node_enter,
+            :on_required_keyword_parameter_node_enter,
+            :on_optional_keyword_parameter_node_enter,
             :on_rest_parameter_node_enter,
             :on_optional_parameter_node_enter,
             :on_keyword_rest_parameter_node_enter,
@@ -359,8 +361,15 @@ module RubyLsp
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
       end
 
-      sig { params(node: Prism::KeywordParameterNode).void }
-      def on_keyword_parameter_node_enter(node)
+      sig { params(node: Prism::RequiredKeywordParameterNode).void }
+      def on_required_keyword_parameter_node_enter(node)
+        return unless matches?(node, LOCAL_NODES)
+
+        add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
+      end
+
+      sig { params(node: Prism::OptionalKeywordParameterNode).void }
+      def on_optional_keyword_parameter_node_enter(node)
         return unless matches?(node, LOCAL_NODES)
 
         add_highlight(Constant::DocumentHighlightKind::WRITE, node.name_loc)
@@ -551,8 +560,8 @@ module RubyLsp
           Prism::ClassVariableTargetNode, Prism::ClassVariableWriteNode, Prism::LocalVariableAndWriteNode,
           Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode, Prism::LocalVariableReadNode,
           Prism::LocalVariableTargetNode, Prism::LocalVariableWriteNode, Prism::DefNode, Prism::BlockParameterNode,
-          Prism::KeywordParameterNode, Prism::KeywordRestParameterNode, Prism::OptionalParameterNode,
-          Prism::RequiredParameterNode, Prism::RestParameterNode
+          Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode, Prism::KeywordRestParameterNode,
+          Prism::OptionalParameterNode, Prism::RequiredParameterNode, Prism::RestParameterNode
 
           node.name.to_s
         when Prism::CallNode

data/lib/ruby_lsp/requests/document_link.rb

@@ -80,11 +80,10 @@ module RubyLsp
           uri: URI::Generic,
           comments: T::Array[Prism::Comment],
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(uri, comments, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      def initialize(uri, comments, dispatcher)
+        super(dispatcher)
 
         # Match the version based on the version in the RBI file name. Notice that the `@` symbol is sanitized to `%40`
         # in the URI

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -49,8 +49,8 @@ module RubyLsp
       sig { override.returns(T::Array[Interface::DocumentSymbol]) }
       attr_reader :_response
 
-      sig { params(dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-      def initialize(dispatcher, message_queue)
+      sig { params(dispatcher: Prism::Dispatcher).void }
+      def initialize(dispatcher)
         @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
         @_response = T.let(@root.children, T::Array[Interface::DocumentSymbol])
         @stack = T.let(
@@ -80,7 +80,7 @@ module RubyLsp
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_document_symbol_listener(@dispatcher, @message_queue)
+        addon.create_document_symbol_listener(@dispatcher)
       end
 
       # Merges responses from other listeners

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -21,9 +21,9 @@ module RubyLsp
 
       ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
 
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher, queue: Thread::Queue).void }
-      def initialize(comments, dispatcher, queue)
-        super(dispatcher, queue)
+      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
+      def initialize(comments, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @requires = T.let([], T::Array[Prism::CallNode])
@@ -40,6 +40,7 @@ module RubyLsp
           :on_array_node_enter,
           :on_block_node_enter,
           :on_case_node_enter,
+          :on_case_match_node_enter,
           :on_class_node_enter,
           :on_module_node_enter,
           :on_for_node_enter,
@@ -51,7 +52,6 @@ module RubyLsp
           :on_else_node_enter,
           :on_ensure_node_enter,
           :on_begin_node_enter,
-          :on_string_concat_node_enter,
           :on_def_node_enter,
           :on_call_node_enter,
           :on_lambda_node_enter,
@@ -91,10 +91,10 @@ module RubyLsp
 
       sig { params(node: Prism::InterpolatedStringNode).void }
       def on_interpolated_string_node_enter(node)
-        opening_loc = node.opening_loc
-        closing_loc = node.closing_loc
+        opening_loc = node.opening_loc || node.location
+        closing_loc = node.closing_loc || node.parts.last&.location || node.location
 
-        add_lines_range(opening_loc.start_line, closing_loc.end_line - 1) if opening_loc && closing_loc
+        add_lines_range(opening_loc.start_line, closing_loc.start_line - 1)
       end
 
       sig { params(node: Prism::ArrayNode).void }
@@ -112,6 +112,11 @@ module RubyLsp
         add_simple_range(node)
       end
 
+      sig { params(node: Prism::CaseMatchNode).void }
+      def on_case_match_node_enter(node)
+        add_simple_range(node)
+      end
+
       sig { params(node: Prism::ClassNode).void }
       def on_class_node_enter(node)
         add_simple_range(node)
@@ -167,14 +172,6 @@ module RubyLsp
         add_simple_range(node)
       end
 
-      sig { params(node: Prism::StringConcatNode).void }
-      def on_string_concat_node_enter(node)
-        left = T.let(node.left, Prism::Node)
-        left = left.left while left.is_a?(Prism::StringConcatNode)
-
-        add_lines_range(left.location.start_line, node.right.location.end_line - 1)
-      end
-
       sig { params(node: Prism::DefNode).void }
       def on_def_node_enter(node)
         params = node.parameters

data/lib/ruby_lsp/requests/formatting.rb

@@ -64,11 +64,6 @@ module RubyLsp
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
         return if @formatter == "none"
-
-        # Don't try to format files outside the current working directory
-        path = @uri.to_standardized_path
-        return unless path.nil? || path.start_with?(T.must(WORKSPACE_URI.to_standardized_path))
-
         return if @document.syntax_error?
 
         formatted_text = formatted_file

data/lib/ruby_lsp/requests/hover.rb

@@ -37,26 +37,26 @@ module RubyLsp
           index: RubyIndexer::Index,
           nesting: T::Array[String],
           dispatcher: Prism::Dispatcher,
-          message_queue: Thread::Queue,
         ).void
       end
-      def initialize(index, nesting, dispatcher, message_queue)
+      def initialize(index, nesting, dispatcher)
         @index = index
         @nesting = nesting
         @_response = T.let(nil, ResponseType)
 
-        super(dispatcher, message_queue)
+        super(dispatcher)
         dispatcher.register(
           self,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
+          :on_call_node_enter,
         )
       end
 
       sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
       def initialize_external_listener(addon)
-        addon.create_hover_listener(@nesting, @index, @dispatcher, @message_queue)
+        addon.create_hover_listener(@nesting, @index, @dispatcher)
       end
 
       # Merges responses from other hover listeners
@@ -95,6 +95,25 @@ module RubyLsp
         generate_hover(node.slice, node.location)
       end
 
+      sig { params(node: Prism::CallNode).void }
+      def on_call_node_enter(node)
+        return if DependencyDetector.instance.typechecker
+        return unless self_receiver?(node)
+
+        message = node.message
+        return unless message
+
+        target_method = @index.resolve_method(message, @nesting.join("::"))
+        return unless target_method
+
+        location = target_method.location
+
+        @_response = Interface::Hover.new(
+          range: range_from_location(location),
+          contents: markdown_from_index_entries(message, target_method),
+        )
+      end
+
       private
 
       sig { params(name: String, location: Prism::Location).void }

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -18,6 +18,16 @@ module RubyLsp
     #   puts "handle some rescue"
     # end
     # ```
+    #
+    # # Example
+    #
+    # ```ruby
+    # var = "foo"
+    # {
+    #   var: var, # Label "var" goes here in cases where the value is omitted
+    #   a: "hello",
+    # }
+    # ```
     class InlayHints < Listener
       extend T::Sig
       extend T::Generic
@@ -29,14 +39,14 @@ module RubyLsp
       sig { override.returns(ResponseType) }
       attr_reader :_response
 
-      sig { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher, message_queue: Thread::Queue).void }
-      def initialize(range, dispatcher, message_queue)
-        super(dispatcher, message_queue)
+      sig { params(range: T::Range[Integer], dispatcher: Prism::Dispatcher).void }
+      def initialize(range, dispatcher)
+        super(dispatcher)
 
         @_response = T.let([], ResponseType)
         @range = range
 
-        dispatcher.register(self, :on_rescue_node_enter)
+        dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end
 
       sig { params(node: Prism::RescueNode).void }
@@ -53,6 +63,34 @@ module RubyLsp
           tooltip: "StandardError is implied in a bare rescue",
         )
       end
+
+      sig { params(node: Prism::ImplicitNode).void }
+      def on_implicit_node_enter(node)
+        return unless visible?(node, @range)
+
+        node_value = node.value
+        loc = node.location
+        tooltip = ""
+        node_name = ""
+        case node_value
+        when Prism::CallNode
+          node_name = node_value.name
+          tooltip = "This is a method call. Method name: #{node_name}"
+        when Prism::ConstantReadNode
+          node_name = node_value.name
+          tooltip = "This is a constant: #{node_name}"
+        when Prism::LocalVariableReadNode
+          node_name = node_value.name
+          tooltip = "This is a local variable: #{node_name}"
+        end
+
+        @_response << Interface::InlayHint.new(
+          position: { line: loc.start_line - 1, character: loc.start_column + node_name.length + 1 },
+          label: node_name,
+          padding_left: true,
+          tooltip: tooltip,
+        )
+      end
     end
   end
 end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -20,8 +20,8 @@ module RubyLsp
 
       END_REGEXES = T.let(
         [
-          /(if|unless|for|while|class|module|until|def|case).*/,
-          /.*\sdo/,
+          /\b(if|unless|for|while|class|module|until|def|case)\b.*/,
+          /.*\s\bdo\b/,
         ],
         T::Array[Regexp],
       )
@@ -51,7 +51,14 @@ module RubyLsp
           if (comment_match = @previous_line.match(/^#(\s*)/))
             handle_comment_line(T.must(comment_match[1]))
           elsif @document.syntax_error?
-            handle_statement_end
+            match = /(?<=<<(-|~))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
+            heredoc_delimiter = match && match.named_captures["delimiter"]
+
+            if heredoc_delimiter
+              handle_heredoc_end(heredoc_delimiter)
+            else
+              handle_statement_end
+            end
           end
         end
 
@@ -121,10 +128,17 @@ module RubyLsp
         end
       end
 
+      sig { params(delimiter: String).void }
+      def handle_heredoc_end(delimiter)
+        indents = " " * @indentation
+        add_edit_with_text("\n")
+        add_edit_with_text("#{indents}#{delimiter}")
+        move_cursor_to(@position[:line], @indentation + 2)
+      end
+
       sig { params(spaces: String).void }
       def handle_comment_line(spaces)
         add_edit_with_text("##{spaces}")
-        move_cursor_to(@position[:line], @indentation + spaces.size + 1)
       end
 
       sig { params(text: String, position: Document::PositionShape).void }