ruby-lsp 0.4.2 → 0.5.0

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Folding ranges demo](../../misc/folding_ranges.gif)
+    # ![Folding ranges demo](../../folding_ranges.gif)
     #
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
     # request informs the editor of the ranges where and how code can be folded.
@@ -63,11 +63,11 @@ module RubyLsp
       def initialize(document)
         super
 
-        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @ranges = T.let([], T::Array[Interface::FoldingRange])
         @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
       def run
         if @document.parsed?
           visit(@document.tree)
@@ -161,9 +161,9 @@ module RubyLsp
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
-        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
+        sig { returns(Interface::FoldingRange) }
         def to_range
-          LanguageServer::Protocol::Interface::FoldingRange.new(
+          Interface::FoldingRange.new(
             start_line: @start_line,
             end_line: @end_line,
             kind: @kind,
@@ -220,7 +220,8 @@ module RubyLsp
 
       sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
-        receiver = T.let(node.receiver, SyntaxTree::Node)
+        receiver = T.let(node.receiver, T.nilable(SyntaxTree::Node))
+
         loop do
           case receiver
           when SyntaxTree::CallNode
@@ -255,9 +256,10 @@ module RubyLsp
       def add_def_range(node)
         # For an endless method with no arguments, `node.params` returns `nil` for Ruby 3.0, but a `Syntax::Params`
         # for Ruby 3.1
-        return unless node.params
+        params = node.params
+        return unless params
 
-        params_location = node.params.location
+        params_location = params.location
 
         if params_location.start_line < params_location.end_line
           add_lines_range(params_location.end_line, node.location.end_line - 1)
@@ -276,7 +278,9 @@ module RubyLsp
 
       sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
-        add_lines_range(node.location.start_line, statements.body.last.location.end_line) unless statements.empty?
+        return if statements.empty?
+
+        add_lines_range(node.location.start_line, T.must(statements.body.last).location.end_line)
       end
 
       sig { params(node: SyntaxTree::StringConcat).void }
@@ -291,7 +295,7 @@ module RubyLsp
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 
-        @ranges << LanguageServer::Protocol::Interface::FoldingRange.new(
+        @ranges << Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
           kind: "region",

data/lib/ruby_lsp/requests/formatting.rb

@@ -2,16 +2,21 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/rubocop_formatting_runner"
+require "ruby_lsp/requests/support/syntax_tree_formatting_runner"
 
 module RubyLsp
   module Requests
-    # ![Formatting symbol demo](../../misc/formatting.gif)
+    # ![Formatting symbol demo](../../formatting.gif)
     #
     # The [formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting)
     # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
     # registering the ruby-lsp as the Ruby formatter.
     #
-    # If RuboCop is not available, the request will fall back to SyntaxTree.
+    # The `rubyLsp.formatter` setting specifies which formatter to use.
+    # If set to `auto`` then it behaves as follows:
+    # * It will use RuboCop if it is part of the bundle.
+    # * If RuboCop is not available, and `syntax_tree` is a direct dependency, it will use that.
+    # * Otherwise, no formatting will be applied.
     #
     # # Example
     #
@@ -26,19 +31,12 @@ module RubyLsp
 
       extend T::Sig
 
-      sig { params(uri: String, document: Document, formatter: String).void }
-      def initialize(uri, document, formatter: "auto")
+      sig { params(document: Document, formatter: String).void }
+      def initialize(document, formatter: "auto")
         super(document)
 
-        @uri = uri
-        @formatter = T.let(
-          if formatter == "auto"
-            defined?(Support::RuboCopFormattingRunner) ? "rubocop" : "syntax_tree"
-          else
-            formatter
-          end,
-          String,
-        )
+        @uri = T.let(document.uri, String)
+        @formatter = formatter
       end
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
@@ -71,9 +69,11 @@ module RubyLsp
       def formatted_file
         case @formatter
         when "rubocop"
-          Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+          if defined?(Support::RuboCopFormattingRunner)
+            Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+          end
         when "syntax_tree"
-          SyntaxTree.format(@document.source)
+          Support::SyntaxTreeFormattingRunner.instance.run(@uri, @document)
         else
           raise InvalidFormatter, "Unknown formatter: #{@formatter}"
         end

data/lib/ruby_lsp/requests/hover.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Hover demo](../../misc/rails_document_link_hover.gif)
+    # ![Hover demo](../../rails_document_link_hover.gif)
     #
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
     # renders a clickable link to the code's official documentation.
@@ -17,8 +17,11 @@ module RubyLsp
     #   before_save :do_something # when hovering on before_save, the link will be rendered
     # end
     # ```
-    class Hover < BaseRequest
+    class Hover < Listener
       extend T::Sig
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
 
       ALLOWED_TARGETS = T.let(
         [
@@ -29,52 +32,60 @@ module RubyLsp
         T::Array[T.class_of(SyntaxTree::Node)],
       )
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      sig { override.returns(ResponseType) }
+      attr_reader :response
+
+      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(emitter, message_queue)
+        super
 
-        @position = T.let(document.create_scanner.find_char_position(position), Integer)
+        @response = T.let(nil, ResponseType)
+        emitter.register(self, :on_command, :on_const_path_ref, :on_call)
       end
 
-      sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }
-      def run
-        return unless @document.parsed?
+      # Merges responses from other hover listeners
+      sig { params(other: Listener[ResponseType]).returns(T.self_type) }
+      def merge_response!(other)
+        other_response = other.response
+        return self unless other_response
 
-        target, parent = locate(T.must(@document.tree), @position)
-        target = parent if !ALLOWED_TARGETS.include?(target.class) && ALLOWED_TARGETS.include?(parent.class)
+        if @response.nil?
+          @response = other.response
+        else
+          @response.contents.value << other_response.contents.value << "\n\n"
+        end
 
-        case target
-        when SyntaxTree::Command
-          message = target.message
-          generate_rails_document_link_hover(message.value, message)
-        when SyntaxTree::CallNode
-          return if target.message == :call
+        self
+      end
 
-          generate_rails_document_link_hover(target.message.value, target.message)
-        when SyntaxTree::ConstPathRef
-          constant_name = full_constant_name(target)
-          generate_rails_document_link_hover(constant_name, target)
-        end
+      sig { params(node: SyntaxTree::Command).void }
+      def on_command(node)
+        message = node.message
+        @response = generate_rails_document_link_hover(message.value, message)
       end
 
-      private
+      sig { params(node: SyntaxTree::ConstPathRef).void }
+      def on_const_path_ref(node)
+        @response = generate_rails_document_link_hover(full_constant_name(node), node)
+      end
+
+      sig { params(node: SyntaxTree::CallNode).void }
+      def on_call(node)
+        message = node.message
+        return if message.is_a?(Symbol)
 
-      sig do
-        params(name: String, node: SyntaxTree::Node).returns(T.nilable(LanguageServer::Protocol::Interface::Hover))
+        @response = generate_rails_document_link_hover(message.value, message)
       end
+
+      private
+
+      sig { params(name: String, node: SyntaxTree::Node).returns(T.nilable(Interface::Hover)) }
       def generate_rails_document_link_hover(name, node)
         urls = Support::RailsDocumentClient.generate_rails_document_urls(name)
-
         return if urls.empty?
 
-        contents = LanguageServer::Protocol::Interface::MarkupContent.new(
-          kind: "markdown",
-          value: urls.join("\n\n"),
-        )
-        LanguageServer::Protocol::Interface::Hover.new(
-          range: range_from_syntax_tree_node(node),
-          contents: contents,
-        )
+        contents = Interface::MarkupContent.new(kind: "markdown", value: urls.join("\n\n"))
+        Interface::Hover.new(range: range_from_syntax_tree_node(node), contents: contents)
       end
     end
   end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Inlay hint demo](../../misc/inlay_hint.gif)
+    # ![Inlay hint demo](../../inlay_hint.gif)
     #
     # [Inlay hints](https://microsoft.github.io/language-server-protocol/specification#textDocument_inlayHint)
     # are labels added directly in the code that explicitly show the user something that might
@@ -25,11 +25,11 @@ module RubyLsp
       def initialize(document, range)
         super(document)
 
-        @hints = T.let([], T::Array[LanguageServer::Protocol::Interface::InlayHint])
+        @hints = T.let([], T::Array[Interface::InlayHint])
         @range = range
       end
 
-      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::InlayHint], Object)) }
+      sig { override.returns(T.all(T::Array[Interface::InlayHint], Object)) }
       def run
         visit(@document.tree) if @document.parsed?
         @hints
@@ -37,12 +37,13 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Rescue).void }
       def visit_rescue(node)
-        return unless node.exception.nil?
+        exception = node.exception
+        return unless exception.nil? || exception.exceptions.nil?
 
         loc = node.location
         return unless visible?(node, @range)
 
-        @hints << LanguageServer::Protocol::Interface::InlayHint.new(
+        @hints << Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },
           label: "StandardError",
           padding_left: true,

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![On type formatting demo](../../misc/on_type_formatting.gif)
+    # ![On type formatting demo](../../on_type_formatting.gif)
     #
     # The [on type formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_onTypeFormatting)
     # request formats code as the user is typing. For example, automatically adding `end` to class definitions.
@@ -80,6 +80,10 @@ module RubyLsp
 
       sig { void }
       def handle_statement_end
+        # If a keyword occurs in a line which appears be a comment or a string, we will not try to format it, since
+        # it could be a coincidental match. This approach is not perfect, but it should cover most cases.
+        return if @previous_line.start_with?(/["'#]/)
+
         return unless END_REGEXES.any? { |regex| regex.match?(@previous_line) }
 
         indents = " " * @indentation

data/lib/ruby_lsp/requests/path_completion.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Path completion demo](../../misc/path_completion.gif)
+    # ![Path completion demo](../../path_completion.gif)
     #
     # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
     # request looks up Ruby files in the $LOAD_PATH to suggest path completion inside `require` statements.
@@ -13,30 +13,28 @@ module RubyLsp
     # ```ruby
     # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
     # ```
-    class PathCompletion < BaseRequest
+    class PathCompletion < Listener
       extend T::Sig
+      extend T::Generic
 
-      sig { params(document: Document, position: Document::PositionShape).void }
-      def initialize(document, position)
-        super(document)
+      ResponseType = type_member { { fixed: T::Array[Interface::CompletionItem] } }
 
-        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
-        @position = position
-      end
+      sig { override.returns(ResponseType) }
+      attr_reader :response
 
-      sig { override.returns(T.all(T::Array[Interface::CompletionItem], Object)) }
-      def run
-        # We can't verify if we're inside a require when there are syntax errors
-        return [] if @document.syntax_error?
+      sig { params(emitter: EventEmitter, message_queue: Thread::Queue).void }
+      def initialize(emitter, message_queue)
+        super
+        @response = T.let([], ResponseType)
+        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
 
-        char_position = @document.create_scanner.find_char_position(@position)
-        target = T.let(find(char_position), T.nilable(SyntaxTree::TStringContent))
-        # no target means the we are not inside a `require` call
-        return [] unless target
+        emitter.register(self, :on_tstring_content)
+      end
 
-        text = target.value
-        @tree.search(text).sort.map! do |path|
-          build_completion(path, path.delete_prefix(text))
+      sig { params(node: SyntaxTree::TStringContent).void }
+      def on_tstring_content(node)
+        @tree.search(node.value).sort.each do |path|
+          @response << build_completion(path, node)
         end
       end
 
@@ -51,41 +49,13 @@ module RubyLsp
         end
       end
 
-      sig { params(position: Integer).returns(T.nilable(SyntaxTree::TStringContent)) }
-      def find(position)
-        matched, parent = locate(
-          T.must(@document.tree),
-          position,
-          node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
-        )
-
-        return unless matched && parent
-
-        case matched
-        when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
-          return unless matched.message.value == "require"
-
-          args = matched.arguments
-          args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
-
-          path_node = args.parts.first.parts.first
-          return unless path_node
-          return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
-
-          path_node
-        end
-      end
-
-      sig { params(label: String, insert_text: String).returns(Interface::CompletionItem) }
-      def build_completion(label, insert_text)
+      sig { params(label: String, node: SyntaxTree::TStringContent).returns(Interface::CompletionItem) }
+      def build_completion(label, node)
         Interface::CompletionItem.new(
           label: label,
           text_edit: Interface::TextEdit.new(
-            range: Interface::Range.new(
-              start: @position,
-              end: @position,
-            ),
-            new_text: insert_text,
+            range: range_from_syntax_tree_node(node),
+            new_text: label,
           ),
           kind: Constant::CompletionItemKind::REFERENCE,
         )

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Selection ranges demo](../../misc/selection_ranges.gif)
+    # ![Selection ranges demo](../../selection_ranges.gif)
     #
     # The [selection ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_selectionRange)
     # request informs the editor of ranges that the user may want to select based on the location(s)
@@ -100,12 +100,12 @@ module RubyLsp
       end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
-          range: LanguageServer::Protocol::Interface::Range.new(
-            start: LanguageServer::Protocol::Interface::Position.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(
               line: location.start_line - 1,
               character: location.start_column,
             ),
-            end: LanguageServer::Protocol::Interface::Position.new(
+            end: Interface::Position.new(
               line: location.end_line - 1,
               character: location.end_column,
             ),

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -3,7 +3,7 @@
 
 module RubyLsp
   module Requests
-    # ![Semantic highlighting demo](../../misc/semantic_highlighting.gif)
+    # ![Semantic highlighting demo](../../semantic_highlighting.gif)
     #
     # The [semantic
     # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)
@@ -122,7 +122,7 @@ module RubyLsp
       sig do
         override.returns(
           T.any(
-            LanguageServer::Protocol::Interface::SemanticTokens,
+            Interface::SemanticTokens,
             T.all(T::Array[SemanticToken], Object),
           ),
         )
@@ -143,7 +143,7 @@ module RubyLsp
         visit(node.receiver)
 
         message = node.message
-        if message != :call && !special_method?(message.value)
+        if !message.is_a?(Symbol) && !special_method?(message.value)
           type = Support::Sorbet.annotation?(node) ? :type : :method
 
           add_token(message.location, type)
@@ -168,7 +168,8 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         visit(node.receiver)
-        add_token(node.message.location, :method)
+        message = node.message
+        add_token(message.location, :method) unless message.is_a?(Symbol)
         visit(node.arguments)
         visit(node.block)
       end
@@ -205,7 +206,7 @@ module RubyLsp
       def visit_params(node)
         return super unless visible?(node, @range)
 
-        node.keywords.each do |keyword,|
+        node.keywords.each do |keyword, *|
           location = keyword.location
           add_token(location_without_colon(location), :parameter)
         end
@@ -215,7 +216,7 @@ module RubyLsp
         end
 
         rest = node.keyword_rest
-        if rest && !rest.is_a?(SyntaxTree::ArgsForward)
+        if rest && !rest.is_a?(SyntaxTree::ArgsForward) && !rest.is_a?(Symbol)
           name = rest.name
           add_token(name.location, :parameter) if name
         end
@@ -238,9 +239,14 @@ module RubyLsp
 
         value = node.value
 
-        if value.is_a?(SyntaxTree::Ident)
+        case value
+        when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
+        else
+          visit(value)
         end
 
         super
@@ -256,6 +262,8 @@ module RubyLsp
         when SyntaxTree::Ident
           type = type_for_local(value)
           add_token(value.location, type)
+        when Symbol
+          # do nothing
         else
           visit(value)
         end
@@ -305,18 +313,21 @@ module RubyLsp
         return unless node.operator == :=~
 
         left = node.left
+        # The regexp needs to be on the left hand side of the =~ for local variable capture
+        return unless left.is_a?(SyntaxTree::RegexpLiteral)
+
         parts = left.parts
+        return unless parts.one?
 
-        if left.is_a?(SyntaxTree::RegexpLiteral) && parts.one? && parts.first.is_a?(SyntaxTree::TStringContent)
-          content = parts.first
+        content = parts.first
+        return unless content.is_a?(SyntaxTree::TStringContent)
 
-          # For each capture name we find in the regexp, look for a local in the current_scope
-          Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
-            local = current_scope.find_local(name)
-            next unless local
+        # For each capture name we find in the regexp, look for a local in the current_scope
+        Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
+          local = current_scope.find_local(name)
+          next unless local
 
-            local.definitions.each { |definition| add_token(definition, :variable) }
-          end
+          local.definitions.each { |definition| add_token(definition, :variable) }
         end
       end
 
@@ -325,7 +336,10 @@ module RubyLsp
         return super unless visible?(node, @range)
 
         add_token(node.constant.location, :class, [:declaration])
-        add_token(node.superclass.location, :class) if node.superclass
+
+        superclass = node.superclass
+        add_token(superclass.location, :class) if superclass
+
         visit(node.bodystmt)
       end
 

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

@@ -0,0 +1,91 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      module Common
+        extend T::Sig
+
+        sig { params(node: SyntaxTree::Node).returns(Interface::Range) }
+        def range_from_syntax_tree_node(node)
+          loc = node.location
+
+          Interface::Range.new(
+            start: Interface::Position.new(
+              line: loc.start_line - 1,
+              character: loc.start_column,
+            ),
+            end: Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
+          )
+        end
+
+        sig do
+          params(node: T.any(SyntaxTree::ConstPathRef, SyntaxTree::ConstRef, SyntaxTree::TopConstRef)).returns(String)
+        end
+        def full_constant_name(node)
+          name = +node.constant.value
+          constant = T.let(node, SyntaxTree::Node)
+
+          while constant.is_a?(SyntaxTree::ConstPathRef)
+            constant = constant.parent
+
+            case constant
+            when SyntaxTree::ConstPathRef
+              name.prepend("#{constant.constant.value}::")
+            when SyntaxTree::VarRef
+              name.prepend("#{constant.value.value}::")
+            end
+          end
+
+          name
+        end
+
+        sig { params(node: T.nilable(SyntaxTree::Node), range: T.nilable(T::Range[Integer])).returns(T::Boolean) }
+        def visible?(node, range)
+          return true if range.nil?
+          return false if node.nil?
+
+          loc = node.location
+          range.cover?(loc.start_line - 1) && range.cover?(loc.end_line - 1)
+        end
+
+        sig do
+          params(
+            node: SyntaxTree::Node,
+            title: String,
+            command_name: String,
+            path: String,
+            name: String,
+            test_command: String,
+            type: String,
+          ).returns(Interface::CodeLens)
+        end
+        def create_code_lens(node, title:, command_name:, path:, name:, test_command:, type:)
+          range = range_from_syntax_tree_node(node)
+          arguments = [
+            path,
+            name,
+            test_command,
+            {
+              start_line: node.location.start_line - 1,
+              start_column: node.location.start_column,
+              end_line: node.location.end_line - 1,
+              end_column: node.location.end_column,
+            },
+          ]
+
+          Interface::CodeLens.new(
+            range: range,
+            command: Interface::Command.new(
+              title: title,
+              command: command_name,
+              arguments: arguments,
+            ),
+            data: { type: type },
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -7,8 +7,8 @@ module RubyLsp
       class HighlightTarget
         extend T::Sig
 
-        READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
-        WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
+        READ = Constant::DocumentHighlightKind::READ
+        WRITE = Constant::DocumentHighlightKind::WRITE
 
         class HighlightMatch
           extend T::Sig
@@ -84,10 +84,11 @@ module RubyLsp
                SyntaxTree::KwRestParam, SyntaxTree::BlockArg
             node.name&.value
           when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall
-            node.value&.value
+            value = node.value
+            value.value unless value.nil? || value.is_a?(Symbol)
           when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
             message = node.message
-            message != :call ? message.value : nil
+            message.value unless message.is_a?(Symbol)
           when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration
             node.constant.constant.value
           end