ruby-lsp 0.10.1 → 0.11.0

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -15,288 +15,265 @@ module RubyLsp
     #   puts "Hello"
     # end # <-- folding range end
     # ```
-    class FoldingRanges < BaseRequest
+    class FoldingRanges < Listener
       extend T::Sig
-
-      SIMPLE_FOLDABLES = T.let(
-        [
-          SyntaxTree::ArrayLiteral,
-          SyntaxTree::BlockNode,
-          SyntaxTree::Case,
-          SyntaxTree::ClassDeclaration,
-          SyntaxTree::For,
-          SyntaxTree::HashLiteral,
-          SyntaxTree::Heredoc,
-          SyntaxTree::ModuleDeclaration,
-          SyntaxTree::SClass,
-          SyntaxTree::UnlessNode,
-          SyntaxTree::UntilNode,
-          SyntaxTree::WhileNode,
-          SyntaxTree::Else,
-          SyntaxTree::Ensure,
-          SyntaxTree::Begin,
-        ].freeze,
-        T::Array[T.class_of(SyntaxTree::Node)],
-      )
-
-      NODES_WITH_STATEMENTS = T.let(
-        [
-          SyntaxTree::IfNode,
-          SyntaxTree::Elsif,
-          SyntaxTree::In,
-          SyntaxTree::Rescue,
-          SyntaxTree::When,
-        ].freeze,
-        T::Array[T.class_of(SyntaxTree::Node)],
-      )
-
-      StatementNode = T.type_alias do
-        T.any(
-          SyntaxTree::IfNode,
-          SyntaxTree::Elsif,
-          SyntaxTree::In,
-          SyntaxTree::Rescue,
-          SyntaxTree::When,
+      extend T::Generic
+
+      ResponseType = type_member { { fixed: T::Array[Interface::FoldingRange] } }
+
+      sig { params(comments: T::Array[YARP::Comment], emitter: EventEmitter, queue: Thread::Queue).void }
+      def initialize(comments, emitter, queue)
+        super(emitter, queue)
+
+        @_response = T.let([], ResponseType)
+        @requires = T.let([], T::Array[YARP::CallNode])
+        @finalized_response = T.let(false, T::Boolean)
+        @comments = comments
+
+        emitter.register(
+          self,
+          :on_if,
+          :on_in,
+          :on_rescue,
+          :on_when,
+          :on_interpolated_string,
+          :on_array,
+          :on_block,
+          :on_case,
+          :on_class,
+          :on_module,
+          :on_for,
+          :on_hash,
+          :on_singleton_class,
+          :on_unless,
+          :on_until,
+          :on_while,
+          :on_else,
+          :on_ensure,
+          :on_begin,
+          :on_string_concat,
+          :on_def,
+          :on_call,
         )
       end
 
-      sig { params(document: Document).void }
-      def initialize(document)
-        super
+      sig { override.returns(ResponseType) }
+      def _response
+        unless @finalized_response
+          push_comment_ranges
+          emit_requires_range
+          @finalized_response = true
+        end
 
-        @ranges = T.let([], T::Array[Interface::FoldingRange])
-        @partial_range = T.let(nil, T.nilable(PartialRange))
+        @_response
       end
 
-      sig { override.returns(T.all(T::Array[Interface::FoldingRange], Object)) }
-      def run
-        if @document.parsed?
-          visit(@document.tree)
-          emit_partial_range
-        end
+      sig { params(node: YARP::IfNode).void }
+      def on_if(node)
+        add_statements_range(node)
+      end
 
-        @ranges
+      sig { params(node: YARP::InNode).void }
+      def on_in(node)
+        add_statements_range(node)
       end
 
-      private
+      sig { params(node: YARP::RescueNode).void }
+      def on_rescue(node)
+        add_statements_range(node)
+      end
 
-      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
-      def visit(node)
-        return unless handle_partial_range(node)
+      sig { params(node: YARP::WhenNode).void }
+      def on_when(node)
+        add_statements_range(node)
+      end
 
-        case node
-        when *SIMPLE_FOLDABLES
-          location = T.must(node).location
-          add_lines_range(location.start_line, location.end_line - 1)
-        when *NODES_WITH_STATEMENTS
-          add_statements_range(T.must(node), T.cast(node, StatementNode).statements)
-        when SyntaxTree::CallNode, SyntaxTree::CommandCall
-          # If there is a receiver, it may be a chained invocation,
-          # so we need to process it in special way.
-          if node.receiver.nil?
-            location = node.location
-            add_lines_range(location.start_line, location.end_line - 1)
-          else
-            add_call_range(node)
-            return
-          end
-        when SyntaxTree::Command
-          unless same_lines_for_command_and_block?(node)
-            location = node.location
-            add_lines_range(location.start_line, location.end_line - 1)
-          end
-        when SyntaxTree::DefNode
-          add_def_range(node)
-        when SyntaxTree::StringConcat
-          add_string_concat(node)
-          return
-        end
+      sig { params(node: YARP::InterpolatedStringNode).void }
+      def on_interpolated_string(node)
+        opening_loc = node.opening_loc
+        closing_loc = node.closing_loc
 
-        super
+        add_lines_range(opening_loc.start_line, closing_loc.end_line - 1) if opening_loc && closing_loc
       end
 
-      # This is to prevent duplicate ranges
-      sig { params(node: T.any(SyntaxTree::Command, SyntaxTree::CommandCall)).returns(T::Boolean) }
-      def same_lines_for_command_and_block?(node)
-        node_block = node.block
-        return false unless node_block
+      sig { params(node: YARP::ArrayNode).void }
+      def on_array(node)
+        add_simple_range(node)
+      end
 
-        location = node.location
-        block_location = node_block.location
-        block_location.start_line == location.start_line && block_location.end_line == location.end_line
+      sig { params(node: YARP::BlockNode).void }
+      def on_block(node)
+        add_simple_range(node)
       end
 
-      class PartialRange
-        extend T::Sig
+      sig { params(node: YARP::CaseNode).void }
+      def on_case(node)
+        add_simple_range(node)
+      end
 
-        sig { returns(String) }
-        attr_reader :kind
+      sig { params(node: YARP::ClassNode).void }
+      def on_class(node)
+        add_simple_range(node)
+      end
 
-        sig { returns(Integer) }
-        attr_reader :end_line
+      sig { params(node: YARP::ModuleNode).void }
+      def on_module(node)
+        add_simple_range(node)
+      end
 
-        class << self
-          extend T::Sig
+      sig { params(node: YARP::ForNode).void }
+      def on_for(node)
+        add_simple_range(node)
+      end
 
-          sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
-          def from(node, kind)
-            new(node.location.start_line - 1, node.location.end_line - 1, kind)
-          end
-        end
+      sig { params(node: YARP::HashNode).void }
+      def on_hash(node)
+        add_simple_range(node)
+      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: YARP::SingletonClassNode).void }
+      def on_singleton_class(node)
+        add_simple_range(node)
+      end
 
-        sig { params(node: SyntaxTree::Node).returns(PartialRange) }
-        def extend_to(node)
-          @end_line = node.location.end_line - 1
-          self
-        end
+      sig { params(node: YARP::UnlessNode).void }
+      def on_unless(node)
+        add_simple_range(node)
+      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 { params(node: YARP::UntilNode).void }
+      def on_until(node)
+        add_simple_range(node)
+      end
 
-        sig { returns(Interface::FoldingRange) }
-        def to_range
-          Interface::FoldingRange.new(
-            start_line: @start_line,
-            end_line: @end_line,
-            kind: @kind,
-          )
-        end
+      sig { params(node: YARP::WhileNode).void }
+      def on_while(node)
+        add_simple_range(node)
+      end
 
-        sig { returns(T::Boolean) }
-        def multiline?
-          @end_line > @start_line
-        end
+      sig { params(node: YARP::ElseNode).void }
+      def on_else(node)
+        add_simple_range(node)
       end
 
-      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T::Boolean) }
-      def handle_partial_range(node)
-        kind = partial_range_kind(node)
+      sig { params(node: YARP::EnsureNode).void }
+      def on_ensure(node)
+        add_simple_range(node)
+      end
 
-        if kind.nil?
-          emit_partial_range
-          return true
-        end
+      sig { params(node: YARP::BeginNode).void }
+      def on_begin(node)
+        add_simple_range(node)
+      end
 
-        target_node = T.must(node)
-        @partial_range = if @partial_range.nil?
-          PartialRange.from(target_node, kind)
-        elsif @partial_range.kind != kind || @partial_range.new_section?(target_node)
-          emit_partial_range
-          PartialRange.from(target_node, kind)
-        else
-          @partial_range.extend_to(target_node)
-        end
+      sig { params(node: YARP::Node).void }
+      def on_node(node)
+        emit_requires_range unless node.is_a?(YARP::CallNode)
+      end
 
-        false
+      sig { params(node: YARP::StringConcatNode).void }
+      def on_string_concat(node)
+        left = T.let(node.left, YARP::Node)
+        left = left.left while left.is_a?(YARP::StringConcatNode)
+
+        add_lines_range(left.location.start_line, node.right.location.end_line - 1)
       end
 
-      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String)) }
-      def partial_range_kind(node)
-        case node
-        when SyntaxTree::Comment
-          "comment"
-        when SyntaxTree::Command
-          if node.message.value == "require" || node.message.value == "require_relative"
-            "imports"
-          end
+      sig { params(node: YARP::DefNode).void }
+      def on_def(node)
+        params = node.parameters
+        parameter_loc = params&.location
+        location = node.location
+
+        if params && parameter_loc.end_line > location.start_line
+          # Multiline parameters
+          add_lines_range(location.start_line, parameter_loc.end_line)
+          add_lines_range(parameter_loc.end_line + 1, location.end_line - 1)
+        else
+          add_lines_range(location.start_line, location.end_line - 1)
         end
       end
 
-      sig { void }
-      def emit_partial_range
-        return if @partial_range.nil?
+      sig { params(node: YARP::CallNode).void }
+      def on_call(node)
+        # If we find a require, don't visit the child nodes (prevent `super`), so that we can keep accumulating into
+        # the `@requires` array and then push the range whenever we find a node that isn't a CallNode
+        if require?(node)
+          @requires << node
+          return
+        end
 
-        @ranges << @partial_range.to_range if @partial_range.multiline?
-        @partial_range = nil
+        location = node.location
+        add_lines_range(location.start_line, location.end_line - 1)
       end
 
-      sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::CommandCall)).void }
-      def add_call_range(node)
-        receiver = T.let(node.receiver, T.nilable(SyntaxTree::Node))
-
-        loop do
-          case receiver
-          when SyntaxTree::CallNode
-            visit(receiver.arguments)
-            receiver = receiver.receiver
-          when SyntaxTree::MethodAddBlock
-            visit(receiver.block)
-            receiver = receiver.call
-
-            if receiver.is_a?(SyntaxTree::CallNode) || receiver.is_a?(SyntaxTree::CommandCall)
-              receiver = receiver.receiver
-            end
-          else
-            break
-          end
+      private
+
+      sig { void }
+      def push_comment_ranges
+        # Group comments that are on consecutive lines and then push ranges for each group that has at least 2 comments
+        @comments.chunk_while do |this, other|
+          this.location.end_line + 1 == other.location.start_line
+        end.each do |chunk|
+          next if chunk.length == 1
+
+          @_response << Interface::FoldingRange.new(
+            start_line: T.must(chunk.first).location.start_line - 1,
+            end_line: T.must(chunk.last).location.end_line - 1,
+            kind: "comment",
+          )
         end
+      end
 
-        if receiver
-          unless node.is_a?(SyntaxTree::CommandCall) && same_lines_for_command_and_block?(node)
-            add_lines_range(
-              receiver.location.start_line,
-              node.location.end_line - 1,
-            )
-          end
+      sig { void }
+      def emit_requires_range
+        if @requires.length > 1
+          @_response << Interface::FoldingRange.new(
+            start_line: T.must(@requires.first).location.start_line - 1,
+            end_line: T.must(@requires.last).location.end_line - 1,
+            kind: "imports",
+          )
         end
 
-        visit(node.arguments)
-        visit(node.block) if node.is_a?(SyntaxTree::CommandCall)
+        @requires.clear
       end
 
-      sig { params(node: SyntaxTree::DefNode).void }
-      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
-        params = node.params
-        return unless params
+      sig { params(node: YARP::CallNode).returns(T::Boolean) }
+      def require?(node)
+        message = node.message
+        return false unless message == "require" || message == "require_relative"
 
-        params_location = params.location
+        receiver = node.receiver
+        return false unless receiver.nil? || receiver.slice == "Kernel"
 
-        if params_location.start_line < params_location.end_line
-          add_lines_range(params_location.end_line, node.location.end_line - 1)
-        else
-          location = node.location
-          add_lines_range(location.start_line, location.end_line - 1)
-        end
+        arguments = node.arguments&.arguments
+        return false unless arguments
 
-        bodystmt = node.bodystmt
-        if bodystmt.is_a?(SyntaxTree::BodyStmt)
-          visit(bodystmt.statements)
-        else
-          visit(bodystmt)
-        end
+        arguments.length == 1 && arguments.first.is_a?(YARP::StringNode)
       end
 
-      sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
-      def add_statements_range(node, statements)
-        return if statements.empty?
+      sig { params(node: T.any(YARP::IfNode, YARP::InNode, YARP::RescueNode, YARP::WhenNode)).void }
+      def add_statements_range(node)
+        statements = node.statements
+        return unless statements
 
-        add_lines_range(node.location.start_line, T.must(statements.body.last).location.end_line)
-      end
+        body = statements.body
+        return if body.empty?
 
-      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(node.location.start_line, T.must(body.last).location.end_line)
+      end
 
-        add_lines_range(left.location.start_line, node.right.location.end_line - 1)
+      sig { params(node: YARP::Node).void }
+      def add_simple_range(node)
+        location = node.location
+        add_lines_range(location.start_line, 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
 
-        @ranges << Interface::FoldingRange.new(
+        @_response << Interface::FoldingRange.new(
           start_line: start_line - 1,
           end_line: end_line - 1,
           kind: "region",

data/lib/ruby_lsp/requests/formatting.rb

@@ -29,12 +29,7 @@ module RubyLsp
       class Error < StandardError; end
       class InvalidFormatter < StandardError; end
 
-      @formatters = T.let(
-        {
-          "syntax_tree" => Support::SyntaxTreeFormattingRunner.instance,
-        },
-        T::Hash[String, Support::FormatterRunner],
-      )
+      @formatters = T.let({}, T::Hash[String, Support::FormatterRunner])
 
       class << self
         extend T::Sig
@@ -52,6 +47,10 @@ module RubyLsp
         register_formatter("rubocop", Support::RuboCopFormattingRunner.instance)
       end
 
+      if defined?(Support::SyntaxTreeFormattingRunner)
+        register_formatter("syntax_tree", Support::SyntaxTreeFormattingRunner.instance)
+      end
+
       extend T::Sig
 
       sig { params(document: Document, formatter: String).void }

data/lib/ruby_lsp/requests/hover.rb

@@ -21,12 +21,12 @@ module RubyLsp
 
       ALLOWED_TARGETS = T.let(
         [
-          SyntaxTree::Const,
-          SyntaxTree::Command,
-          SyntaxTree::CallNode,
-          SyntaxTree::ConstPathRef,
+          YARP::CallNode,
+          YARP::ConstantReadNode,
+          YARP::ConstantWriteNode,
+          YARP::ConstantPathNode,
         ],
-        T::Array[T.class_of(SyntaxTree::Node)],
+        T::Array[T.class_of(YARP::Node)],
       )
 
       sig { override.returns(ResponseType) }
@@ -41,17 +41,17 @@ module RubyLsp
         ).void
       end
       def initialize(index, nesting, emitter, message_queue)
-        @nesting = nesting
         @index = index
+        @nesting = nesting
         @_response = T.let(nil, ResponseType)
 
         super(emitter, message_queue)
-        emitter.register(self, :on_const_path_ref, :on_const)
+        emitter.register(self, :on_constant_read, :on_constant_write, :on_constant_path)
       end
 
-      sig { override.params(extension: RubyLsp::Extension).returns(T.nilable(Listener[ResponseType])) }
-      def initialize_external_listener(extension)
-        extension.create_hover_listener(@emitter, @message_queue)
+      sig { override.params(addon: Addon).returns(T.nilable(Listener[ResponseType])) }
+      def initialize_external_listener(addon)
+        addon.create_hover_listener(@nesting, @index, @emitter, @message_queue)
       end
 
       # Merges responses from other hover listeners
@@ -69,30 +69,41 @@ module RubyLsp
         self
       end
 
-      sig { params(node: SyntaxTree::ConstPathRef).void }
-      def on_const_path_ref(node)
-        return if DependencyDetector::HAS_TYPECHECKER
+      sig { params(node: YARP::ConstantReadNode).void }
+      def on_constant_read(node)
+        return if DependencyDetector.instance.typechecker
+
+        generate_hover(node.slice, node.location)
+      end
+
+      sig { params(node: YARP::ConstantWriteNode).void }
+      def on_constant_write(node)
+        return if DependencyDetector.instance.typechecker
 
-        name = full_constant_name(node)
-        generate_hover(name, node)
+        generate_hover(node.name.to_s, node.name_loc)
       end
 
-      sig { params(node: SyntaxTree::Const).void }
-      def on_const(node)
-        return if DependencyDetector::HAS_TYPECHECKER
+      sig { params(node: YARP::ConstantPathNode).void }
+      def on_constant_path(node)
+        return if DependencyDetector.instance.typechecker
 
-        generate_hover(node.value, node)
+        generate_hover(node.slice, node.location)
       end
 
       private
 
-      sig { params(name: String, node: SyntaxTree::Node).void }
-      def generate_hover(name, node)
+      sig { params(name: String, location: YARP::Location).void }
+      def generate_hover(name, location)
         entries = @index.resolve(name, @nesting)
         return unless entries
 
+        # We should only show hover for private constants if the constant is defined in the same namespace as the
+        # reference
+        first_entry = T.must(entries.first)
+        return if first_entry.visibility == :private && first_entry.name != "#{@nesting.join("::")}::#{name}"
+
         @_response = Interface::Hover.new(
-          range: range_from_syntax_tree_node(node),
+          range: range_from_location(location),
           contents: markdown_from_index_entries(name, entries),
         )
       end

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -39,10 +39,9 @@ module RubyLsp
         emitter.register(self, :on_rescue)
       end
 
-      sig { params(node: SyntaxTree::Rescue).void }
+      sig { params(node: YARP::RescueNode).void }
       def on_rescue(node)
-        exception = node.exception
-        return unless exception.nil? || exception.exceptions.nil?
+        return unless node.exceptions.empty?
 
         loc = node.location
         return unless visible?(node, @range)