ruby-lsp 0.0.3 → 0.2.0

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -1,7 +1,10 @@
+# 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
@@ -24,7 +27,9 @@ module RubyLsp
     # end
     # ```
     class DocumentSymbol < BaseRequest
-      SYMBOL_KIND = {
+      extend T::Sig
+
+      SYMBOL_KIND = T.let({
         file: 1,
         module: 2,
         namespace: 3,
@@ -51,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
@@ -88,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)
 
@@ -103,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,
@@ -112,6 +129,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::Def).void }
       def visit_def(node)
         name = node.name.value
 
@@ -127,6 +145,7 @@ module RubyLsp
         @stack.pop
       end
 
+      sig { params(node: SyntaxTree::DefEndless).void }
       def visit_def_endless(node)
         name = node.name.value
 
@@ -142,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}",
@@ -155,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
@@ -168,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,
@@ -177,6 +199,7 @@ module RubyLsp
         )
       end
 
+      sig { params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
         kind = case node.value
         when SyntaxTree::Const
@@ -197,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,
@@ -206,19 +237,28 @@ module RubyLsp
           children: [],
         )
 
-        @stack.last.children << symbol
+        T.must(@stack.last).children << symbol
 
         symbol
       end
 
-      def range_from_syntax_tree_node(node)
-        loc = node.location
+      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
 
-        LanguageServer::Protocol::Interface::Range.new(
-          start: LanguageServer::Protocol::Interface::Position.new(line: loc.start_line - 1,
-            character: loc.start_column),
-          end: LanguageServer::Protocol::Interface::Position.new(line: loc.end_line - 1, character: loc.end_column),
-        )
+        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

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -1,18 +1,24 @@
+# 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,
@@ -29,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
@@ -55,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
@@ -79,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,
@@ -107,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)
 
@@ -117,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
@@ -140,15 +177,17 @@ 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 = node.receiver
+        receiver = T.let(node.receiver, SyntaxTree::Node)
         loop do
           case receiver
           when SyntaxTree::Call
@@ -162,42 +201,39 @@ module RubyLsp
           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 = node.left
+        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,7 +1,12 @@
+# 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.
@@ -13,38 +18,43 @@ module RubyLsp
     # puts "Hello" # --> formatting: fixes the indentation on save
     # end
     # ```
-    class Formatting < RuboCopRequest
-      RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--auto-correct"]).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
 
         [
           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

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -1,7 +1,10 @@
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
+    # ![Selection ranges demo](../../misc/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)
     # of their cursor(s).
@@ -16,7 +19,9 @@ module RubyLsp
     # end
     # ```
     class SelectionRanges < BaseRequest
-      NODES_THAT_CAN_BE_PARENTS = [
+      extend T::Sig
+
+      NODES_THAT_CAN_BE_PARENTS = T.let([
         SyntaxTree::Assign,
         SyntaxTree::ArrayLiteral,
         SyntaxTree::Begin,
@@ -53,15 +58,17 @@ module RubyLsp
         SyntaxTree::VCall,
         SyntaxTree::When,
         SyntaxTree::While,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
 
+      sig { params(document: Document).void }
       def initialize(document)
         super(document)
 
-        @ranges = []
-        @stack = []
+        @ranges = T.let([], T::Array[Support::SelectionRange])
+        @stack = T.let([], T::Array[Support::SelectionRange])
       end
 
+      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def run
         visit(@document.tree)
         @ranges.reverse!
@@ -69,6 +76,7 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return if node.nil?
 
@@ -82,6 +90,12 @@ module RubyLsp
         @stack.pop if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
       end
 
+      sig do
+        params(
+          location: SyntaxTree::Location,
+          parent: T.nilable(Support::SelectionRange)
+        ).returns(Support::SelectionRange)
+      end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
           range: LanguageServer::Protocol::Interface::Range.new(