ruby-lsp 0.3.6 → 0.3.8

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -18,34 +18,38 @@ module RubyLsp
     class FoldingRanges < BaseRequest
       extend T::Sig
 
-      SIMPLE_FOLDABLES = T.let([
-        SyntaxTree::ArrayLiteral,
-        SyntaxTree::BraceBlock,
-        SyntaxTree::Case,
-        SyntaxTree::ClassDeclaration,
-        SyntaxTree::Command,
-        SyntaxTree::DoBlock,
-        SyntaxTree::FCall,
-        SyntaxTree::For,
-        SyntaxTree::HashLiteral,
-        SyntaxTree::Heredoc,
-        SyntaxTree::If,
-        SyntaxTree::ModuleDeclaration,
-        SyntaxTree::SClass,
-        SyntaxTree::Unless,
-        SyntaxTree::Until,
-        SyntaxTree::While,
-        SyntaxTree::Else,
-        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, T::Array[T.class_of(SyntaxTree::Node)])
+      SIMPLE_FOLDABLES = T.let(
+        [
+          SyntaxTree::ArrayLiteral,
+          SyntaxTree::BlockNode,
+          SyntaxTree::Case,
+          SyntaxTree::ClassDeclaration,
+          SyntaxTree::Command,
+          SyntaxTree::For,
+          SyntaxTree::HashLiteral,
+          SyntaxTree::Heredoc,
+          SyntaxTree::IfNode,
+          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::Elsif,
+          SyntaxTree::In,
+          SyntaxTree::Rescue,
+          SyntaxTree::When,
+        ].freeze,
+        T::Array[T.class_of(SyntaxTree::Node)],
+      )
 
       StatementNode = T.type_alias do
         T.any(
@@ -86,10 +90,17 @@ module RubyLsp
           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::Call, SyntaxTree::CommandCall
-          add_call_range(node)
-          return
-        when SyntaxTree::Def, SyntaxTree::Defs
+        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::DefNode
           add_def_range(node)
         when SyntaxTree::StringConcat
           add_string_concat(node)
@@ -192,19 +203,19 @@ module RubyLsp
         @partial_range = nil
       end
 
-      sig { params(node: T.any(SyntaxTree::Call, SyntaxTree::CommandCall)).void }
+      sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
         receiver = T.let(node.receiver, SyntaxTree::Node)
         loop do
           case receiver
-          when SyntaxTree::Call
+          when SyntaxTree::CallNode
             visit(receiver.arguments)
             receiver = receiver.receiver
           when SyntaxTree::MethodAddBlock
             visit(receiver.block)
             receiver = receiver.call
 
-            if receiver.is_a?(SyntaxTree::Call) || receiver.is_a?(SyntaxTree::CommandCall)
+            if receiver.is_a?(SyntaxTree::CallNode) || receiver.is_a?(SyntaxTree::CommandCall)
               receiver = receiver.receiver
             end
           else
@@ -212,13 +223,17 @@ module RubyLsp
           end
         end
 
-        add_lines_range(receiver.location.start_line, node.location.end_line - 1)
+        add_lines_range(receiver.location.start_line, node.location.end_line - 1) if receiver
 
         visit(node.arguments)
       end
 
-      sig { params(node: T.any(SyntaxTree::Def, SyntaxTree::Defs)).void }
+      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
+        return unless node.params
+
         params_location = node.params.location
 
         if params_location.start_line < params_location.end_line
@@ -228,7 +243,12 @@ module RubyLsp
           add_lines_range(location.start_line, location.end_line - 1)
         end
 
-        visit(node.bodystmt.statements)
+        bodystmt = node.bodystmt
+        if bodystmt.is_a?(SyntaxTree::BodyStmt)
+          visit(bodystmt.statements)
+        else
+          visit(bodystmt)
+        end
       end
 
       sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }

data/lib/ruby_lsp/requests/formatting.rb

@@ -11,6 +11,8 @@ module RubyLsp
     # 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.
+    #
     # # Example
     #
     # ```ruby

data/lib/ruby_lsp/requests/hover.rb

@@ -20,28 +20,37 @@ module RubyLsp
     class Hover < BaseRequest
       extend T::Sig
 
+      ALLOWED_TARGETS = T.let(
+        [
+          SyntaxTree::Command,
+          SyntaxTree::CallNode,
+          SyntaxTree::ConstPathRef,
+        ],
+        T::Array[T.class_of(SyntaxTree::Node)],
+      )
+
       sig { params(document: Document, position: Document::PositionShape).void }
       def initialize(document, position)
         super(document)
 
-        @position = T.let(Document::Scanner.new(document.source).find_position(position), Integer)
+        @position = T.let(document.create_scanner.find_char_position(position), Integer)
       end
 
       sig { override.returns(T.nilable(LanguageServer::Protocol::Interface::Hover)) }
       def run
         return unless @document.parsed?
 
-        target, _ = locate_node_and_parent(
-          T.must(@document.tree), [SyntaxTree::Command, SyntaxTree::FCall, SyntaxTree::ConstPathRef], @position
-        )
+        target, parent = locate(T.must(@document.tree), @position)
+        target = parent if !ALLOWED_TARGETS.include?(target.class) && ALLOWED_TARGETS.include?(parent.class)
 
         case target
         when SyntaxTree::Command
           message = target.message
           generate_rails_document_link_hover(message.value, message)
-        when SyntaxTree::FCall
-          message = target.value
-          generate_rails_document_link_hover(message.value, message)
+        when SyntaxTree::CallNode
+          return if target.message == :call
+
+          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)

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -40,7 +40,7 @@ module RubyLsp
         return unless node.exception.nil?
 
         loc = node.location
-        return unless @range.cover?(loc.start_line - 1) && @range.cover?(loc.end_line - 1)
+        return unless visible?(node, @range)
 
         @hints << LanguageServer::Protocol::Interface::InlayHint.new(
           position: { line: loc.start_line - 1, character: loc.start_column + RESCUE_STRING_LENGTH },

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -18,18 +18,21 @@ module RubyLsp
     class OnTypeFormatting < BaseRequest
       extend T::Sig
 
-      END_REGEXES = T.let([
-        /(if|unless|for|while|class|module|until|def|case).*/,
-        /.*\sdo/,
-      ], T::Array[Regexp])
+      END_REGEXES = T.let(
+        [
+          /(if|unless|for|while|class|module|until|def|case).*/,
+          /.*\sdo/,
+        ],
+        T::Array[Regexp],
+      )
 
       sig { params(document: Document, position: Document::PositionShape, trigger_character: String).void }
       def initialize(document, position, trigger_character)
         super(document)
 
-        scanner = Document::Scanner.new(document.source)
-        line_begin = position[:line] == 0 ? 0 : scanner.find_position({ line: position[:line] - 1, character: 0 })
-        line_end = scanner.find_position(position)
+        scanner = document.create_scanner
+        line_begin = position[:line] == 0 ? 0 : scanner.find_char_position({ line: position[:line] - 1, character: 0 })
+        line_end = scanner.find_char_position(position)
         line = T.must(@document.source[line_begin..line_end])
 
         @indentation = T.let(find_indentation(line), Integer)
@@ -41,17 +44,17 @@ module RubyLsp
 
       sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
       def run
-        handle_comment_line
-
-        return @edits unless @document.syntax_errors?
-
         case @trigger_character
         when "{"
-          handle_curly_brace
+          handle_curly_brace if @document.syntax_error?
         when "|"
-          handle_pipe
+          handle_pipe if @document.syntax_error?
         when "\n"
-          handle_statement_end
+          if (comment_match = @previous_line.match(/^#(\s*)/))
+            handle_comment_line(T.must(comment_match[1]))
+          elsif @document.syntax_error?
+            handle_statement_end
+          end
         end
 
         @edits
@@ -85,14 +88,8 @@ module RubyLsp
         move_cursor_to(@position[:line], @indentation + 2)
       end
 
-      sig { void }
-      def handle_comment_line
-        return unless @trigger_character == "\n"
-
-        is_comment_match = @previous_line.match(/^#(\s*)/)
-        return unless is_comment_match
-
-        spaces = T.must(is_comment_match[1])
+      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

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -11,6 +11,8 @@ module RubyLsp
     #
     # Trigger this request with: Ctrl + Shift + -> or Ctrl + Shift + <-
     #
+    # Note that if using VSCode Neovim, you will need to be in Insert mode for this to work correctly.
+    #
     # # Example
     #
     # ```ruby
@@ -21,44 +23,44 @@ module RubyLsp
     class SelectionRanges < BaseRequest
       extend T::Sig
 
-      NODES_THAT_CAN_BE_PARENTS = T.let([
-        SyntaxTree::Assign,
-        SyntaxTree::ArrayLiteral,
-        SyntaxTree::Begin,
-        SyntaxTree::BraceBlock,
-        SyntaxTree::Call,
-        SyntaxTree::Case,
-        SyntaxTree::ClassDeclaration,
-        SyntaxTree::Command,
-        SyntaxTree::Def,
-        SyntaxTree::Defs,
-        SyntaxTree::DoBlock,
-        SyntaxTree::Elsif,
-        SyntaxTree::Else,
-        SyntaxTree::EmbDoc,
-        SyntaxTree::Ensure,
-        SyntaxTree::FCall,
-        SyntaxTree::For,
-        SyntaxTree::HashLiteral,
-        SyntaxTree::Heredoc,
-        SyntaxTree::HeredocBeg,
-        SyntaxTree::HshPtn,
-        SyntaxTree::If,
-        SyntaxTree::In,
-        SyntaxTree::Lambda,
-        SyntaxTree::MethodAddBlock,
-        SyntaxTree::ModuleDeclaration,
-        SyntaxTree::Params,
-        SyntaxTree::Rescue,
-        SyntaxTree::RescueEx,
-        SyntaxTree::StringConcat,
-        SyntaxTree::StringLiteral,
-        SyntaxTree::Unless,
-        SyntaxTree::Until,
-        SyntaxTree::VCall,
-        SyntaxTree::When,
-        SyntaxTree::While,
-      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
+      NODES_THAT_CAN_BE_PARENTS = T.let(
+        [
+          SyntaxTree::Assign,
+          SyntaxTree::ArrayLiteral,
+          SyntaxTree::Begin,
+          SyntaxTree::BlockNode,
+          SyntaxTree::CallNode,
+          SyntaxTree::Case,
+          SyntaxTree::ClassDeclaration,
+          SyntaxTree::Command,
+          SyntaxTree::DefNode,
+          SyntaxTree::Elsif,
+          SyntaxTree::Else,
+          SyntaxTree::EmbDoc,
+          SyntaxTree::Ensure,
+          SyntaxTree::For,
+          SyntaxTree::HashLiteral,
+          SyntaxTree::Heredoc,
+          SyntaxTree::HeredocBeg,
+          SyntaxTree::HshPtn,
+          SyntaxTree::IfNode,
+          SyntaxTree::In,
+          SyntaxTree::Lambda,
+          SyntaxTree::MethodAddBlock,
+          SyntaxTree::ModuleDeclaration,
+          SyntaxTree::Params,
+          SyntaxTree::Rescue,
+          SyntaxTree::RescueEx,
+          SyntaxTree::StringConcat,
+          SyntaxTree::StringLiteral,
+          SyntaxTree::UnlessNode,
+          SyntaxTree::UntilNode,
+          SyntaxTree::VCall,
+          SyntaxTree::When,
+          SyntaxTree::WhileNode,
+        ].freeze,
+        T::Array[T.class_of(SyntaxTree::Node)],
+      )
 
       sig { params(document: Document).void }
       def initialize(document)

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -22,52 +22,61 @@ module RubyLsp
       extend T::Sig
       include SyntaxTree::WithEnvironment
 
-      TOKEN_TYPES = T.let({
-        namespace: 0,
-        type: 1,
-        class: 2,
-        enum: 3,
-        interface: 4,
-        struct: 5,
-        typeParameter: 6,
-        parameter: 7,
-        variable: 8,
-        property: 9,
-        enumMember: 10,
-        event: 11,
-        function: 12,
-        method: 13,
-        macro: 14,
-        keyword: 15,
-        modifier: 16,
-        comment: 17,
-        string: 18,
-        number: 19,
-        regexp: 20,
-        operator: 21,
-        decorator: 22,
-      }.freeze, T::Hash[Symbol, Integer])
-
-      TOKEN_MODIFIERS = T.let({
-        declaration: 0,
-        definition: 1,
-        readonly: 2,
-        static: 3,
-        deprecated: 4,
-        abstract: 5,
-        async: 6,
-        modification: 7,
-        documentation: 8,
-        default_library: 9,
-      }.freeze, T::Hash[Symbol, Integer])
-
-      SPECIAL_RUBY_METHODS = T.let([
-        Module.instance_methods(false),
-        Kernel.instance_methods(false),
-        Kernel.methods(false),
-        Bundler::Dsl.instance_methods(false),
-        Module.private_instance_methods(false),
-      ].flatten.map(&:to_s), T::Array[String])
+      TOKEN_TYPES = T.let(
+        {
+          namespace: 0,
+          type: 1,
+          class: 2,
+          enum: 3,
+          interface: 4,
+          struct: 5,
+          typeParameter: 6,
+          parameter: 7,
+          variable: 8,
+          property: 9,
+          enumMember: 10,
+          event: 11,
+          function: 12,
+          method: 13,
+          macro: 14,
+          keyword: 15,
+          modifier: 16,
+          comment: 17,
+          string: 18,
+          number: 19,
+          regexp: 20,
+          operator: 21,
+          decorator: 22,
+        }.freeze,
+        T::Hash[Symbol, Integer],
+      )
+
+      TOKEN_MODIFIERS = T.let(
+        {
+          declaration: 0,
+          definition: 1,
+          readonly: 2,
+          static: 3,
+          deprecated: 4,
+          abstract: 5,
+          async: 6,
+          modification: 7,
+          documentation: 8,
+          default_library: 9,
+        }.freeze,
+        T::Hash[Symbol, Integer],
+      )
+
+      SPECIAL_RUBY_METHODS = T.let(
+        [
+          Module.instance_methods(false),
+          Kernel.instance_methods(false),
+          Kernel.methods(false),
+          Bundler::Dsl.instance_methods(false),
+          Module.private_instance_methods(false),
+        ].flatten.map(&:to_s),
+        T::Array[String],
+      )
 
       class SemanticToken < T::Struct
         const :location, SyntaxTree::Location
@@ -76,13 +85,20 @@ module RubyLsp
         const :modifier, T::Array[Integer]
       end
 
-      sig { params(document: Document, encoder: T.nilable(Support::SemanticTokenEncoder)).void }
-      def initialize(document, encoder: nil)
+      sig do
+        params(
+          document: Document,
+          range: T.nilable(T::Range[Integer]),
+          encoder: T.nilable(Support::SemanticTokenEncoder),
+        ).void
+      end
+      def initialize(document, range: nil, encoder: nil)
         super(document)
 
         @encoder = encoder
         @tokens = T.let([], T::Array[SemanticToken])
         @tree = T.let(T.must(document.tree), SyntaxTree::Node)
+        @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
       end
 
@@ -103,24 +119,32 @@ module RubyLsp
         @encoder.encode(@tokens)
       end
 
-      sig { override.params(node: SyntaxTree::Call).void }
+      sig { override.params(node: SyntaxTree::CallNode).void }
       def visit_call(node)
+        return super unless visible?(node, @range)
+
         visit(node.receiver)
 
         message = node.message
-        add_token(message.location, :method) if message != :call
+        unless message == :call || special_method?(message.value)
+          add_token(message.location, :method)
+        end
 
         visit(node.arguments)
       end
 
       sig { override.params(node: SyntaxTree::Command).void }
       def visit_command(node)
+        return super unless visible?(node, @range)
+
         add_token(node.message.location, :method) unless special_method?(node.message.value)
         visit(node.arguments)
       end
 
       sig { override.params(node: SyntaxTree::CommandCall).void }
       def visit_command_call(node)
+        return super unless visible?(node, @range)
+
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
@@ -128,41 +152,26 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Const).void }
       def visit_const(node)
+        return super unless visible?(node, @range)
+
         add_token(node.location, :namespace)
       end
 
-      sig { override.params(node: SyntaxTree::Def).void }
+      sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
-        add_token(node.name.location, :method, [:declaration])
-        visit(node.params)
-        visit(node.bodystmt)
-      end
-
-      sig { override.params(node: SyntaxTree::DefEndless).void }
-      def visit_def_endless(node)
-        add_token(node.name.location, :method, [:declaration])
-        visit(node.paren)
-        visit(node.operator)
-        visit(node.statement)
-      end
+        return super unless visible?(node, @range)
 
-      sig { override.params(node: SyntaxTree::Defs).void }
-      def visit_defs(node)
-        visit(node.target)
-        visit(node.operator)
         add_token(node.name.location, :method, [:declaration])
         visit(node.params)
         visit(node.bodystmt)
-      end
-
-      sig { override.params(node: SyntaxTree::FCall).void }
-      def visit_fcall(node)
-        add_token(node.value.location, :method) unless special_method?(node.value.value)
-        visit(node.arguments)
+        visit(node.target) if node.target
+        visit(node.operator) if node.operator
       end
 
       sig { override.params(node: SyntaxTree::Kw).void }
       def visit_kw(node)
+        return super unless visible?(node, @range)
+
         case node.value
         when "self"
           add_token(node.location, :variable, [:default_library])
@@ -171,6 +180,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Params).void }
       def visit_params(node)
+        return super unless visible?(node, @range)
+
         node.keywords.each do |keyword,|
           location = keyword.location
           add_token(location_without_colon(location), :parameter)
@@ -191,6 +202,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::Field).void }
       def visit_field(node)
+        return super unless visible?(node, @range)
+
         add_token(node.name.location, :method)
 
         super
@@ -198,6 +211,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarField).void }
       def visit_var_field(node)
+        return super unless visible?(node, @range)
+
         value = node.value
 
         case value
@@ -211,6 +226,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VarRef).void }
       def visit_var_ref(node)
+        return super unless visible?(node, @range)
+
         value = node.value
 
         case value
@@ -224,11 +241,15 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
+        return super unless visible?(node, @range)
+
         add_token(node.value.location, :method) unless special_method?(node.value.value)
       end
 
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
       def visit_class(node)
+        return super unless visible?(node, @range)
+
         add_token(node.constant.location, :class, [:declaration])
         add_token(node.superclass.location, :class) if node.superclass
         visit(node.bodystmt)
@@ -236,6 +257,8 @@ module RubyLsp
 
       sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
       def visit_module(node)
+        return super unless visible?(node, @range)
+
         add_token(node.constant.location, :class, [:declaration])
         visit(node.bodystmt)
       end