ruby-lsp 0.0.4 → 0.2.1

data/lib/ruby_lsp/requests/diagnostics.rb

@@ -1,8 +1,12 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/rubocop_diagnostics_runner"
+
 module RubyLsp
   module Requests
+    # ![Diagnostics demo](../../misc/diagnostics.gif)
+    #
     # The
     # [diagnostics](https://microsoft.github.io/language-server-protocol/specification#textDocument_publishDiagnostics)
     # request informs the editor of RuboCop offenses for a given file.
@@ -14,21 +18,34 @@ module RubyLsp
     # puts "Hello" # --> diagnostics: incorrect indentantion
     # end
     # ```
-    class Diagnostics < RuboCopRequest
-      def run
-        return syntax_error_diagnostics if @document.syntax_errors?
+    class Diagnostics < BaseRequest
+      extend T::Sig
 
-        super
+      sig { params(uri: String, document: Document).void }
+      def initialize(uri, document)
+        super(document)
 
-        @diagnostics
+        @uri = uri
       end
 
-      def file_finished(_file, offenses)
-        @diagnostics = offenses.map { |offense| Support::RuboCopDiagnostic.new(offense, @uri) }
+      sig do
+        override.returns(
+          T.any(
+            T.all(T::Array[Support::RuboCopDiagnostic], Object),
+            T.all(T::Array[Support::SyntaxErrorDiagnostic], Object),
+          )
+        )
+      end
+      def run
+        return syntax_error_diagnostics if @document.syntax_errors?
+        return [] unless defined?(Support::RuboCopDiagnosticsRunner)
+
+        Support::RuboCopDiagnosticsRunner.instance.run(@uri, @document)
       end
 
       private
 
+      sig { returns(T::Array[Support::SyntaxErrorDiagnostic]) }
       def syntax_error_diagnostics
         @document.syntax_error_edits.map { |e| Support::SyntaxErrorDiagnostic.new(e) }
       end

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -1,8 +1,10 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Document highlight demo](../../misc/document_highlight.gif)
+    #
     # The [document highlight](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentHighlight)
     # informs the editor all relevant elements of the currently pointed item for highlighting. For example, when
     # the cursor is on the `F` of the constant `FOO`, the editor should identify other occurences of `FOO`
@@ -21,18 +23,18 @@ module RubyLsp
     # end
     # ```
     class DocumentHighlight < BaseRequest
-      def self.run(document, position)
-        new(document, position).run
-      end
+      extend T::Sig
 
+      sig { params(document: Document, position: Document::PositionShape).void }
       def initialize(document, position)
-        @highlights = []
+        @highlights = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentHighlight])
         position = Document::Scanner.new(document.source).find_position(position)
-        @target = find(document.tree, position)
+        @target = T.let(find(T.must(document.tree), position), T.nilable(Support::HighlightTarget))
 
         super(document)
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentHighlight], Object)) }
       def run
         # no @target means the target is not highlightable
         return [] unless @target
@@ -41,30 +43,24 @@ module RubyLsp
         @highlights
       end
 
-      def visit_var_field(node)
-        if matches_target?(node.value)
-          add_highlight(
-            node.value,
-            LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
-          )
-        end
-
-        super
-      end
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
+      def visit(node)
+        return if node.nil?
 
-      def visit_var_ref(node)
-        if matches_target?(node.value)
-          add_highlight(
-            node.value,
-            LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
-          )
-        end
+        match = T.must(@target).highlight_type(node)
+        add_highlight(match) if match
 
         super
       end
 
       private
 
+      sig do
+        params(
+          node: SyntaxTree::Node,
+          position: Integer,
+        ).returns(T.nilable(Support::HighlightTarget))
+      end
       def find(node, position)
         matched =
           node.child_nodes.compact.bsearch do |child|
@@ -76,20 +72,24 @@ module RubyLsp
           end
 
         case matched
-        when SyntaxTree::GVar, SyntaxTree::Ident, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar
-          matched
+        when SyntaxTree::GVar,
+             SyntaxTree::IVar,
+             SyntaxTree::Const,
+             SyntaxTree::CVar,
+             SyntaxTree::VarField
+          Support::HighlightTarget.new(matched)
+        when SyntaxTree::Ident
+          relevant_node = node.is_a?(SyntaxTree::Params) ? matched : node
+          Support::HighlightTarget.new(relevant_node)
         when SyntaxTree::Node
           find(matched, position)
         end
       end
 
-      def matches_target?(node)
-        node.is_a?(@target.class) && node.value == @target.value
-      end
-
-      def add_highlight(node, kind)
-        range = range_from_syntax_tree_node(node)
-        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: kind)
+      sig { params(match: Support::HighlightTarget::HighlightMatch).void }
+      def add_highlight(match)
+        range = range_from_syntax_tree_node(match.node)
+        @highlights << LanguageServer::Protocol::Interface::DocumentHighlight.new(range: range, kind: match.type)
       end
     end
   end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -1,8 +1,10 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Document symbol demo](../../misc/document_symbol.gif)
+    #
     # The [document
     # symbol](https://microsoft.github.io/language-server-protocol/specification#textDocument_documentSymbol) request
     # informs the editor of all the important symbols, such as classes, variables, and methods, defined in a file. With
@@ -25,7 +27,9 @@ module RubyLsp
     # end
     # ```
     class DocumentSymbol < BaseRequest
-      SYMBOL_KIND = {
+      extend T::Sig
+
+      SYMBOL_KIND = T.let({
         file: 1,
         module: 2,
         namespace: 3,
@@ -52,33 +56,43 @@ module RubyLsp
         event: 24,
         operator: 25,
         typeparameter: 26,
-      }.freeze
+      }.freeze, T::Hash[Symbol, Integer])
 
-      ATTR_ACCESSORS = ["attr_reader", "attr_writer", "attr_accessor"].freeze
+      ATTR_ACCESSORS = T.let(["attr_reader", "attr_writer", "attr_accessor"].freeze, T::Array[String])
 
       class SymbolHierarchyRoot
+        extend T::Sig
+
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol]) }
         attr_reader :children
 
+        sig { void }
         def initialize
-          @children = []
+          @children = T.let([], T::Array[LanguageServer::Protocol::Interface::DocumentSymbol])
         end
       end
 
+      sig { params(document: Document).void }
       def initialize(document)
         super
 
-        @root = SymbolHierarchyRoot.new
-        @stack = [@root]
+        @root = T.let(SymbolHierarchyRoot.new, SymbolHierarchyRoot)
+        @stack = T.let(
+          [@root],
+          T::Array[T.any(SymbolHierarchyRoot, LanguageServer::Protocol::Interface::DocumentSymbol)]
+        )
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::DocumentSymbol], Object)) }
       def run
         visit(@document.tree)
         @root.children
       end
 
+      sig { params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
         symbol = create_document_symbol(
-          name: node.constant.constant.value,
+          name: fully_qualified_name(node),
           kind: :class,
           range_node: node,
           selection_range_node: node.constant
@@ -89,6 +103,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::Command).void }
       def visit_command(node)
         return unless ATTR_ACCESSORS.include?(node.message.value)
 
@@ -104,6 +119,7 @@ module RubyLsp
         end
       end
 
+      sig { params(node: SyntaxTree::ConstPathField).void }
       def visit_const_path_field(node)
         create_document_symbol(
           name: node.constant.value,
@@ -113,6 +129,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::Def).void }
       def visit_def(node)
         name = node.name.value
 
@@ -128,6 +145,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::DefEndless).void }
       def visit_def_endless(node)
         name = node.name.value
 
@@ -143,6 +161,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::Defs).void }
       def visit_defs(node)
         symbol = create_document_symbol(
           name: "self.#{node.name.value}",
@@ -156,9 +175,10 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
         symbol = create_document_symbol(
-          name: node.constant.constant.value,
+          name: fully_qualified_name(node),
           kind: :module,
           range_node: node,
           selection_range_node: node.constant
@@ -169,6 +189,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::TopConstField).void }
       def visit_top_const_field(node)
         create_document_symbol(
           name: node.constant.value,
@@ -178,6 +199,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         kind = case node.value
         when SyntaxTree::Const
@@ -198,6 +220,14 @@ module RubyLsp
 
       private
 
+      sig do
+        params(
+          name: String,
+          kind: Symbol,
+          range_node: SyntaxTree::Node,
+          selection_range_node: SyntaxTree::Node
+        ).returns(LanguageServer::Protocol::Interface::DocumentSymbol)
+      end
       def create_document_symbol(name:, kind:, range_node:, selection_range_node:)
         symbol = LanguageServer::Protocol::Interface::DocumentSymbol.new(
           name: name,
@@ -207,10 +237,29 @@ module RubyLsp
           children: [],
         )
 
-        @stack.last.children << symbol
+        T.must(@stack.last).children << symbol
 
         symbol
       end
+
+      sig { params(node: T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)).returns(String) }
+      def fully_qualified_name(node)
+        constant = T.let(node.constant, SyntaxTree::Node)
+        name = +node.constant.constant.value
+
+        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
     end
   end
 end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -1,19 +1,24 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Folding ranges demo](../../misc/folding_ranges.gif)
+    #
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
-    # request informs the editor of the ranges where code can be folded.
+    # request informs the editor of the ranges where and how code can be folded.
     #
     # # Example
+    #
     # ```ruby
     # def say_hello # <-- folding range start
     #   puts "Hello"
     # end # <-- folding range end
     # ```
     class FoldingRanges < BaseRequest
-      SIMPLE_FOLDABLES = [
+      extend T::Sig
+
+      SIMPLE_FOLDABLES = T.let([
         SyntaxTree::ArrayLiteral,
         SyntaxTree::BraceBlock,
         SyntaxTree::Case,
@@ -30,24 +35,36 @@ module RubyLsp
         SyntaxTree::Unless,
         SyntaxTree::Until,
         SyntaxTree::While,
-      ].freeze
-
-      NODES_WITH_STATEMENTS = [
         SyntaxTree::Else,
-        SyntaxTree::Elsif,
         SyntaxTree::Ensure,
+        SyntaxTree::Begin,
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
+
+      NODES_WITH_STATEMENTS = T.let([
+        SyntaxTree::Elsif,
         SyntaxTree::In,
         SyntaxTree::Rescue,
         SyntaxTree::When,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
+
+      StatementNode = T.type_alias do
+        T.any(
+          SyntaxTree::Elsif,
+          SyntaxTree::In,
+          SyntaxTree::Rescue,
+          SyntaxTree::When,
+        )
+      end
 
+      sig { params(document: Document).void }
       def initialize(document)
         super
 
-        @ranges = []
-        @partial_range = nil
+        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
       def run
         visit(@document.tree)
         emit_partial_range
@@ -56,16 +73,16 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return unless handle_partial_range(node)
 
         case node
         when *SIMPLE_FOLDABLES
-          add_node_range(node)
+          location = T.must(node).location
+          add_lines_range(location.start_line, location.end_line - 1)
         when *NODES_WITH_STATEMENTS
-          add_statements_range(node, node.statements)
-        when SyntaxTree::Begin
-          add_statements_range(node, node.bodystmt.statements)
+          add_statements_range(T.must(node), T.cast(node, StatementNode).statements)
         when SyntaxTree::Call, SyntaxTree::CommandCall
           add_call_range(node)
           return
@@ -80,27 +97,38 @@ module RubyLsp
       end
 
       class PartialRange
-        attr_reader :kind, :end_line
+        extend T::Sig
 
+        sig { returns(String) }
+        attr_reader :kind
+
+        sig { returns(Integer) }
+        attr_reader :end_line
+
+        sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
         def self.from(node, kind)
           new(node.location.start_line - 1, node.location.end_line - 1, kind)
         end
 
+        sig { params(start_line: Integer, end_line: Integer, kind: String).void }
         def initialize(start_line, end_line, kind)
           @start_line = start_line
           @end_line = end_line
           @kind = kind
         end
 
+        sig { params(node: SyntaxTree::Node).returns(PartialRange) }
         def extend_to(node)
           @end_line = node.location.end_line - 1
           self
         end
 
+        sig { params(node: SyntaxTree::Node).returns(T::Boolean) }
         def new_section?(node)
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
         def to_range
           LanguageServer::Protocol::Interface::FoldingRange.new(
             start_line: @start_line,
@@ -108,8 +136,14 @@ module RubyLsp
             kind: @kind
           )
         end
+
+        sig { returns(T::Boolean) }
+        def multiline?
+          @end_line > @start_line
+        end
       end
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T::Boolean) }
       def handle_partial_range(node)
         kind = partial_range_kind(node)
 
@@ -118,18 +152,20 @@ module RubyLsp
           return true
         end
 
+        target_node = T.must(node)
         @partial_range = if @partial_range.nil?
-          PartialRange.from(node, kind)
-        elsif @partial_range.kind != kind || @partial_range.new_section?(node)
+          PartialRange.from(target_node, kind)
+        elsif @partial_range.kind != kind || @partial_range.new_section?(target_node)
           emit_partial_range
-          PartialRange.from(node, kind)
+          PartialRange.from(target_node, kind)
         else
-          @partial_range.extend_to(node)
+          @partial_range.extend_to(target_node)
         end
 
         false
       end
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String)) }
       def partial_range_kind(node)
         case node
         when SyntaxTree::Comment
@@ -141,13 +177,15 @@ module RubyLsp
         end
       end
 
+      sig { void }
       def emit_partial_range
         return if @partial_range.nil?
 
-        @ranges << @partial_range.to_range
+        @ranges << @partial_range.to_range if @partial_range.multiline?
         @partial_range = nil
       end
 
+      sig { params(node: T.any(SyntaxTree::Call, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
         receiver = T.let(node.receiver, SyntaxTree::Node)
         loop do
@@ -157,48 +195,49 @@ module RubyLsp
             receiver = receiver.receiver
           when SyntaxTree::MethodAddBlock
             visit(receiver.block)
-            receiver = receiver.call.receiver
+            receiver = receiver.call
+
+            if receiver.is_a?(SyntaxTree::Call) || receiver.is_a?(SyntaxTree::CommandCall)
+              receiver = receiver.receiver
+            end
           else
             break
           end
         end
 
-        add_lines_range(receiver.location.start_line, node.location.end_line)
+        add_lines_range(receiver.location.start_line, node.location.end_line - 1)
 
         visit(node.arguments)
       end
 
+      sig { params(node: T.any(SyntaxTree::Def, SyntaxTree::Defs)).void }
       def add_def_range(node)
         params_location = node.params.location
 
         if params_location.start_line < params_location.end_line
-          add_lines_range(params_location.end_line, node.location.end_line)
+          add_lines_range(params_location.end_line, node.location.end_line - 1)
         else
-          add_node_range(node)
+          location = node.location
+          add_lines_range(location.start_line, location.end_line - 1)
         end
 
         visit(node.bodystmt.statements)
       end
 
+      sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
-        add_lines_range(node.location.start_line, statements.location.end_line) unless statements.empty?
+        add_lines_range(node.location.start_line, statements.body.last.location.end_line) unless statements.empty?
       end
 
+      sig { params(node: SyntaxTree::StringConcat).void }
       def add_string_concat(node)
         left = T.let(node.left, SyntaxTree::Node)
         left = left.left while left.is_a?(SyntaxTree::StringConcat)
 
-        add_lines_range(left.location.start_line, node.right.location.end_line)
-      end
-
-      def add_node_range(node)
-        add_location_range(node.location)
-      end
-
-      def add_location_range(location)
-        add_lines_range(location.start_line, location.end_line)
+        add_lines_range(left.location.start_line, node.right.location.end_line - 1)
       end
 
+      sig { params(start_line: Integer, end_line: Integer).void }
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,8 +1,12 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/requests/support/rubocop_formatting_runner"
+
 module RubyLsp
   module Requests
+    # ![Formatting symbol demo](../../misc/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.
@@ -14,38 +18,44 @@ module RubyLsp
     # puts "Hello" # --> formatting: fixes the indentation on save
     # end
     # ```
-    class Formatting < RuboCopRequest
-      RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--autocorrect"]).freeze
+    class Formatting < BaseRequest
+      extend T::Sig
 
+      sig { params(uri: String, document: Document).void }
       def initialize(uri, document)
-        super
-        @formatted_text = nil
+        super(document)
+
+        @uri = uri
       end
 
+      sig { override.returns(T.nilable(T.all(T::Array[LanguageServer::Protocol::Interface::TextEdit], Object))) }
       def run
-        super
+        formatted_text = formatted_file
+        return unless formatted_text
 
-        @formatted_text = @options[:stdin] # Rubocop applies the corrections on stdin
-        return unless @formatted_text
+        size = @document.source.size
+        return if formatted_text.size == size && formatted_text == @document.source
 
         [
           LanguageServer::Protocol::Interface::TextEdit.new(
             range: LanguageServer::Protocol::Interface::Range.new(
               start: LanguageServer::Protocol::Interface::Position.new(line: 0, character: 0),
-              end: LanguageServer::Protocol::Interface::Position.new(
-                line: text.size,
-                character: text.size
-              )
+              end: LanguageServer::Protocol::Interface::Position.new(line: size, character: size)
             ),
-            new_text: @formatted_text
+            new_text: formatted_text
           ),
         ]
       end
 
       private
 
-      def rubocop_flags
-        RUBOCOP_FLAGS
+      sig { returns(T.nilable(String)) }
+      def formatted_file
+        if defined?(Support::RuboCopFormattingRunner)
+          Support::RuboCopFormattingRunner.instance.run(@uri, @document)
+        else
+          SyntaxTree.format(@document.source)
+        end
       end
     end
   end