ruby-lsp 0.3.7 → 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,6 +20,15 @@ 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)
@@ -31,17 +40,17 @@ module RubyLsp
       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/on_type_formatting.rb

@@ -18,10 +18,13 @@ 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)
@@ -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
@@ -110,14 +119,16 @@ 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
@@ -146,42 +157,15 @@ module RubyLsp
         add_token(node.location, :namespace)
       end
 
-      sig { override.params(node: SyntaxTree::Def).void }
+      sig { override.params(node: SyntaxTree::DefNode).void }
       def visit_def(node)
         return super unless visible?(node, @range)
 
         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)
-        return super unless visible?(node, @range)
-
-        add_token(node.name.location, :method, [:declaration])
-        visit(node.paren)
-        visit(node.operator)
-        visit(node.statement)
-      end
-
-      sig { override.params(node: SyntaxTree::Defs).void }
-      def visit_defs(node)
-        return super unless visible?(node, @range)
-
-        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)
-        return super unless visible?(node, @range)
-
-        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 }

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

@@ -34,12 +34,12 @@ module RubyLsp
         def matched_highlight(other)
           case @node
           # Method definitions and invocations
-          when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command,
-               SyntaxTree::CommandCall, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless
+          when SyntaxTree::VCall, SyntaxTree::CallNode, SyntaxTree::Command,
+               SyntaxTree::CommandCall, SyntaxTree::DefNode
             case other
-            when SyntaxTree::VCall, SyntaxTree::FCall, SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+            when SyntaxTree::VCall, SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
               HighlightMatch.new(type: READ, node: other)
-            when SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::Defs
+            when SyntaxTree::DefNode
               HighlightMatch.new(type: WRITE, node: other.name)
             end
           # Variables, parameters and constants
@@ -67,15 +67,14 @@ module RubyLsp
           case node
           when SyntaxTree::ConstPathRef, SyntaxTree::ConstPathField, SyntaxTree::TopConstField
             node.constant.value
-          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::Ident,
-               SyntaxTree::ArgsForward
+          when SyntaxTree::GVar, SyntaxTree::IVar, SyntaxTree::Const, SyntaxTree::CVar, SyntaxTree::Ident
             node.value
-          when SyntaxTree::Field, SyntaxTree::Def, SyntaxTree::Defs, SyntaxTree::DefEndless, SyntaxTree::RestParam,
+          when SyntaxTree::Field, SyntaxTree::DefNode, SyntaxTree::RestParam,
                SyntaxTree::KwRestParam, SyntaxTree::BlockArg
             node.name&.value
-          when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall, SyntaxTree::FCall
+          when SyntaxTree::VarField, SyntaxTree::VarRef, SyntaxTree::VCall
             node.value&.value
-          when SyntaxTree::Call, SyntaxTree::Command, SyntaxTree::CommandCall
+          when SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall
             message = node.message
             message != :call ? message.value : nil
           when SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration

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

@@ -10,8 +10,14 @@ module RubyLsp
         RAILS_DOC_HOST = "https://api.rubyonrails.org"
         SUPPORTED_RAILS_DOC_NAMESPACES = T.let(
           Regexp.union(
-            /ActionDispatch/, /ActionController/, /AbstractController/, /ActiveRecord/, /ActiveModel/, /ActiveStorage/,
-            /ActionText/, /ActiveJob/
+            /ActionDispatch/,
+            /ActionController/,
+            /AbstractController/,
+            /ActiveRecord/,
+            /ActiveModel/,
+            /ActiveStorage/,
+            /ActionText/,
+            /ActiveJob/,
           ).freeze,
           Regexp,
         )
@@ -19,7 +25,8 @@ module RubyLsp
         RAILTIES_VERSION = T.let(
           [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].find do |s|
             s.name == "railties"
-          end&.version&.to_s, T.nilable(String)
+          end&.version&.to_s,
+          T.nilable(String),
         )
 
         class << self
@@ -59,7 +66,7 @@ module RubyLsp
           private def build_search_index
             return unless RAILTIES_VERSION
 
-            $stderr.puts "Fetching Rails Documents..."
+            warn("Fetching Rails Documents...")
             # If the version's doc is not found, e.g. Rails main, it'll be redirected
             # In this case, we just fetch the latest doc
             response = if Gem::Version.new(RAILTIES_VERSION).prerelease?
@@ -71,11 +78,11 @@ module RubyLsp
             if response.code == "200"
               process_search_index(response.body)
             else
-              $stderr.puts("Response failed: #{response.inspect}")
+              warn("Response failed: #{response.inspect}")
               nil
             end
           rescue StandardError => e
-            $stderr.puts("Exception occurred when fetching Rails document index: #{e.inspect}")
+            warn("Exception occurred when fetching Rails document index: #{e.inspect}")
           end
 
           sig { params(js: String).returns(T::Hash[String, T::Array[T::Hash[Symbol, String]]]) }

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

@@ -7,14 +7,17 @@ module RubyLsp
       class RuboCopDiagnostic
         extend T::Sig
 
-        RUBOCOP_TO_LSP_SEVERITY = T.let({
-          convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-          info: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-          refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
-          warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
-          error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-          fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-        }.freeze, T::Hash[Symbol, Integer])
+        RUBOCOP_TO_LSP_SEVERITY = T.let(
+          {
+            convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+            info: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+            refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
+            warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
+            error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+            fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
+          }.freeze,
+          T::Hash[Symbol, Integer],
+        )
 
         sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
         attr_reader :replacements
@@ -94,8 +97,10 @@ module RubyLsp
             LanguageServer::Protocol::Interface::TextEdit.new(
               range: LanguageServer::Protocol::Interface::Range.new(
                 start: LanguageServer::Protocol::Interface::Position.new(line: range.line - 1, character: range.column),
-                end: LanguageServer::Protocol::Interface::Position.new(line: range.last_line - 1,
-                  character: range.last_column),
+                end: LanguageServer::Protocol::Interface::Position.new(
+                  line: range.last_line - 1,
+                  character: range.last_column,
+                ),
               ),
               new_text: replacement,
             )

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

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/rubocop_runner"
-return unless defined?(::RubyLsp::Requests::Support::RuboCopRunner)
+return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
 require "cgi"
 require "singleton"

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

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/rubocop_runner"
-return unless defined?(::RubyLsp::Requests::Support::RuboCopRunner)
+return unless defined?(RubyLsp::Requests::Support::RuboCopRunner)
 
 require "cgi"
 require "singleton"