ruby-lsp 0.23.15 → 0.26.9

data/lib/ruby_lsp/listeners/completion.rb

@@ -50,7 +50,7 @@ module RubyLsp
         "__LINE__",
       ].freeze
 
-      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, GlobalState global_state, NodeContext node_context, RubyDocument::SorbetLevel sorbet_level, Prism::Dispatcher dispatcher, URI::Generic uri, String? trigger_character) -> void
+      #: (ResponseBuilders::CollectionResponseBuilder[Interface::CompletionItem] response_builder, GlobalState global_state, NodeContext node_context, SorbetLevel sorbet_level, Prism::Dispatcher dispatcher, URI::Generic uri, String? trigger_character) -> void
       def initialize( # rubocop:disable Metrics/ParameterLists
         response_builder,
         global_state,
@@ -100,7 +100,7 @@ module RubyLsp
       def on_constant_read_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
+        return unless @sorbet_level.ignore?
 
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -125,7 +125,7 @@ module RubyLsp
       def on_constant_path_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
+        return unless @sorbet_level.ignore?
 
         name = begin
           node.full_name
@@ -143,7 +143,7 @@ module RubyLsp
       def on_call_node_enter(node)
         # The only scenario where Sorbet doesn't provide constant completion is on ignored files. Even if the file has
         # no sigil, Sorbet will still provide completion for constants
-        if @sorbet_level == RubyDocument::SorbetLevel::Ignore
+        if @sorbet_level.ignore?
           receiver = node.receiver
 
           # When writing `Foo::`, the AST assigns a method call node (because you can use that syntax to invoke
@@ -390,7 +390,7 @@ module RubyLsp
       def handle_instance_variable_completion(name, location)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
-        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+        return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -445,11 +445,14 @@ module RubyLsp
         return unless arguments_node
 
         path_node_to_complete = arguments_node.arguments.first
-
         return unless path_node_to_complete.is_a?(Prism::StringNode)
 
-        origin_dir = Pathname.new(@uri.to_standardized_path).dirname
+        # If the file is unsaved (e.g.: untitled:Untitled-1), we can't provide relative completion as we don't know
+        # where the user intends to save it
+        full_path = @uri.to_standardized_path
+        return unless full_path
 
+        origin_dir = Pathname.new(full_path).dirname
         content = path_node_to_complete.content
         # if the path is not a directory, glob all possible next characters
         # for example ../somethi| (where | is the cursor position)
@@ -475,13 +478,13 @@ module RubyLsp
       def complete_methods(node, name)
         # If the node has a receiver, then we don't need to provide local nor keyword completions. Sorbet can provide
         # local and keyword completion for any file with a Sorbet level of true or higher
-        if !sorbet_level_true_or_higher?(@sorbet_level) && !node.receiver
+        if !@sorbet_level.true_or_higher? && !node.receiver
           add_local_completions(node, name)
           add_keyword_completions(node, name)
         end
 
         # Sorbet can provide completion for methods invoked on self on typed true or higher files
-        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+        return if @sorbet_level.true_or_higher? && self_receiver?(node)
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -512,10 +515,18 @@ module RubyLsp
         external_references = @node_context.fully_qualified_name != type.name
 
         @index.method_completion_candidates(method_name, type.name).each do |entry|
-          next if entry.visibility != RubyIndexer::Entry::Visibility::PUBLIC && external_references
+          next if entry.visibility != :public && external_references
 
           entry_name = entry.name
           owner_name = entry.owner&.name
+          new_text = entry_name
+
+          if entry_name.end_with?("=")
+            method_name = entry_name.delete_suffix("=")
+
+            # For writer methods, format as assignment and prefix "self." when no receiver is specified
+            new_text = node.receiver.nil? ? "self.#{method_name} = " : "#{method_name} = "
+          end
 
           label_details = Interface::CompletionItemLabelDetails.new(
             description: entry.file_name,
@@ -525,7 +536,7 @@ module RubyLsp
             label: entry_name,
             filter_text: entry_name,
             label_details: label_details,
-            text_edit: Interface::TextEdit.new(range: range, new_text: entry_name),
+            text_edit: Interface::TextEdit.new(range: range, new_text: new_text),
             kind: Constant::CompletionItemKind::METHOD,
             data: {
               owner_name: owner_name,

data/lib/ruby_lsp/listeners/definition.rb

@@ -8,7 +8,7 @@ module RubyLsp
 
       MAX_NUMBER_OF_DEFINITION_CANDIDATES_WITHOUT_RECEIVER = 10
 
-      #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, GlobalState global_state, Document::LanguageId language_id, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: (ResponseBuilders::CollectionResponseBuilder[(Interface::Location | Interface::LocationLink)] response_builder, GlobalState global_state, Symbol language_id, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
@@ -53,7 +53,7 @@ module RubyLsp
       #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
         # Sorbet can handle go to definition for methods invoked on self on typed true or higher
-        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+        return if @sorbet_level.true_or_higher? && self_receiver?(node)
 
         message = node.message
         return unless message
@@ -62,7 +62,7 @@ module RubyLsp
 
         # Until we can properly infer the receiver type in erb files (maybe with ruby-lsp-rails),
         # treating method calls' type as `nil` will allow users to get some completion support first
-        if @language_id == Document::LanguageId::ERB && inferrer_receiver_type&.name == "Object"
+        if @language_id == :erb && inferrer_receiver_type&.name == "Object"
           inferrer_receiver_type = nil
         end
 
@@ -71,24 +71,26 @@ module RubyLsp
 
       #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
-        enclosing_call = @node_context.call_node
-        return unless enclosing_call
-
-        name = enclosing_call.name
-        return unless name == :require || name == :require_relative
-
-        handle_require_definition(node, name)
+        with_enclosing_call(node) do |enclosing_call, name|
+          case name
+          when :require, :require_relative
+            handle_require_definition(node, name)
+          when :send, :public_send
+            handle_send_or_public_send_definition(enclosing_call, node) { node.content }
+          end
+        end
       end
 
       #: (Prism::SymbolNode node) -> void
       def on_symbol_node_enter(node)
-        enclosing_call = @node_context.call_node
-        return unless enclosing_call
-
-        name = enclosing_call.name
-        return unless name == :autoload
-
-        handle_autoload_definition(enclosing_call)
+        with_enclosing_call(node) do |enclosing_call, name|
+          case name
+          when :autoload
+            handle_autoload_definition(enclosing_call)
+          when :send, :public_send
+            handle_send_or_public_send_definition(enclosing_call, node) { node.unescaped }
+          end
+        end
       end
 
       #: (Prism::BlockArgumentNode node) -> void
@@ -220,10 +222,28 @@ module RubyLsp
 
       private
 
+      #: (Prism::Node node) { (Prism::CallNode, Symbol) -> void } -> void
+      def with_enclosing_call(node, &block)
+        enclosing_call = @node_context.call_node
+        return unless enclosing_call
+
+        block.call(enclosing_call, enclosing_call.name)
+      end
+
+      #: (Prism::CallNode enclosing_call, Prism::Node node) { -> String } -> void
+      def handle_send_or_public_send_definition(enclosing_call, node, &block)
+        first_argument = enclosing_call.arguments&.arguments&.first
+        return unless first_argument.eql?(node)
+
+        method_name = block.call
+
+        handle_method_definition(method_name, nil)
+      end
+
       #: -> void
       def handle_super_node_definition
         # Sorbet can handle super hover on typed true or higher
-        return if sorbet_level_true_or_higher?(@sorbet_level)
+        return if @sorbet_level.true_or_higher?
 
         surrounding_method = @node_context.surrounding_method
         return unless surrounding_method
@@ -276,7 +296,7 @@ module RubyLsp
       def handle_instance_variable_definition(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
-        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+        return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -317,7 +337,7 @@ module RubyLsp
         methods.each do |target_method|
           uri = target_method.uri
           full_path = uri.full_path
-          next if sorbet_level_true_or_higher?(@sorbet_level) && (!full_path || not_in_dependencies?(full_path))
+          next if @sorbet_level.true_or_higher? && (!full_path || not_in_dependencies?(full_path))
 
           @response_builder << Interface::LocationLink.new(
             target_uri: uri.to_s,
@@ -392,7 +412,7 @@ module RubyLsp
           uri = entry.uri
           full_path = uri.full_path
 
-          if @sorbet_level != RubyDocument::SorbetLevel::Ignore && (!full_path || not_in_dependencies?(full_path))
+          if !@sorbet_level.ignore? && (!full_path || not_in_dependencies?(full_path))
             next
           end
 

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -92,7 +92,8 @@ module RubyLsp
             Prism::RequiredParameterNode, Prism::RestParameterNode
             [target, node_value(target)]
           when Prism::ModuleNode, Prism::ClassNode, Prism::SingletonClassNode, Prism::DefNode, Prism::CaseNode,
-            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode
+            Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::IfNode, Prism::UnlessNode, Prism::BlockNode,
+            Prism::LambdaNode, Prism::BeginNode
             [target, nil]
           end
 
@@ -157,6 +158,9 @@ module RubyLsp
             :on_for_node_enter,
             :on_if_node_enter,
             :on_unless_node_enter,
+            :on_block_node_enter,
+            :on_lambda_node_enter,
+            :on_begin_node_enter,
           )
         end
       end
@@ -551,6 +555,27 @@ module RubyLsp
         add_matching_end_highlights(node.keyword_loc, node.end_keyword_loc)
       end
 
+      #: (Prism::BlockNode node) -> void
+      def on_block_node_enter(node)
+        return unless @target.is_a?(Prism::BlockNode)
+
+        add_matching_end_highlights(node.opening_loc, node.closing_loc)
+      end
+
+      #: (Prism::LambdaNode node) -> void
+      def on_lambda_node_enter(node)
+        return unless @target.is_a?(Prism::LambdaNode)
+
+        add_matching_end_highlights(node.opening_loc, node.closing_loc)
+      end
+
+      #: (Prism::BeginNode node) -> void
+      def on_begin_node_enter(node)
+        return unless @target.is_a?(Prism::BeginNode)
+
+        add_matching_end_highlights(node.begin_keyword_loc, node.end_keyword_loc)
+      end
+
       private
 
       #: (Prism::Node node, Array[singleton(Prism::Node)] classes) -> bool?

data/lib/ruby_lsp/listeners/document_link.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "ruby_lsp/requests/support/source_uri"
+require "ruby_lsp/requests/support/package_url"
 
 module RubyLsp
   module Listeners
@@ -59,6 +60,7 @@ module RubyLsp
         @lines_to_comments = comments.to_h do |comment|
           [comment.location.end_line, comment]
         end #: Hash[Integer, Prism::Comment]
+        @sig_comments = {} #: Hash[Integer, Prism::Comment]
 
         dispatcher.register(
           self,
@@ -67,9 +69,20 @@ module RubyLsp
           :on_module_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_write_node_enter,
+          :on_call_node_enter,
         )
       end
 
+      #: (Prism::CallNode node) -> void
+      def on_call_node_enter(node)
+        return unless node.name == :sig
+
+        comment = @lines_to_comments[node.location.start_line - 1]
+        return unless comment
+
+        @sig_comments[node.location.end_line] = comment
+      end
+
       #: (Prism::DefNode node) -> void
       def on_def_node_enter(node)
         extract_document_link(node)
@@ -99,58 +112,81 @@ module RubyLsp
 
       #: (Prism::Node node) -> void
       def extract_document_link(node)
-        comment = @lines_to_comments[node.location.start_line - 1]
+        comment = @lines_to_comments[node.location.start_line - 1] || @sig_comments[node.location.start_line - 1]
         return unless comment
 
-        match = comment.location.slice.match(%r{source://.*#\d+$})
+        match = comment.location.slice.match(%r{(source://.*#\d+|pkg:gem/.*#.*)$})
         return unless match
 
-        uri = T.cast(
-          begin
-            URI(
-              match[0], #: as !nil
-            )
-          rescue URI::Error
-            nil
-          end,
-          T.nilable(URI::Source),
+        uri_string = match[0] #: as !nil
+
+        file_path, line_number = if uri_string.start_with?("pkg:gem/")
+          parse_package_url(uri_string)
+        else
+          parse_source_uri(uri_string)
+        end
+
+        return unless file_path
+
+        @response_builder << Interface::DocumentLink.new(
+          range: range_from_location(comment.location),
+          target: "file://#{file_path}##{line_number}",
+          tooltip: "Jump to #{file_path}##{line_number}",
         )
+      end
+
+      #: (String uri_string) -> [String, String]?
+      def parse_package_url(uri_string)
+        purl = PackageURL.parse(uri_string) #: as PackageURL?
+        return unless purl
+
+        gem_version = resolve_version(purl.version, purl.name)
+        return if gem_version.nil?
+
+        path, line_number = purl.subpath.split(":", 2)
+        return unless path
+
+        gem_name = purl.name
+        file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
+        return if file_path.nil?
+
+        [file_path, line_number]
+      rescue PackageURL::InvalidPackageURL
+        nil
+      end
+
+      #: (String uri_string) -> [String, String]?
+      def parse_source_uri(uri_string)
+        uri = begin
+          URI(uri_string)
+        rescue URI::Error
+          nil
+        end #: as URI::Source?
         return unless uri
 
-        gem_version = resolve_version(uri)
+        gem_version = resolve_version(uri.gem_version, uri.gem_name)
         return if gem_version.nil?
 
         path = uri.path
         return unless path
 
-        gem_name = uri.gem_name
-        return unless gem_name
-
-        file_path = self.class.gem_paths.dig(gem_name, gem_version, CGI.unescape(path))
+        file_path = self.class.gem_paths.dig(uri.gem_name, gem_version, CGI.unescape(path))
         return if file_path.nil?
 
-        @response_builder << Interface::DocumentLink.new(
-          range: range_from_location(comment.location),
-          target: "file://#{file_path}##{uri.line_number}",
-          tooltip: "Jump to #{file_path}##{uri.line_number}",
-        )
+        [file_path, uri.line_number || "0"]
       end
 
       # Try to figure out the gem version for a source:// link. The order of precedence is:
       # 1. The version in the URI
       # 2. The version in the RBI file name
       # 3. The version from the gemspec
-      #: (URI::Source uri) -> String?
-      def resolve_version(uri)
-        version = uri.gem_version
+      #: (String? version, String? gem_name) -> String?
+      def resolve_version(version, gem_name)
         return version unless version.nil? || version.empty?
 
         return @gem_version unless @gem_version.nil? || @gem_version.empty?
 
-        gem_name = uri.gem_name
-        return unless gem_name
-
-        GEM_TO_VERSION_MAP[gem_name]
+        GEM_TO_VERSION_MAP[gem_name.to_s]
       end
     end
   end

data/lib/ruby_lsp/listeners/hover.rb

@@ -7,6 +7,7 @@ module RubyLsp
       include Requests::Support::Common
 
       ALLOWED_TARGETS = [
+        Prism::BreakNode,
         Prism::CallNode,
         Prism::ConstantReadNode,
         Prism::ConstantWriteNode,
@@ -42,7 +43,7 @@ module RubyLsp
         "https://gitlab.com",
       ].freeze #: Array[String]
 
-      #: (ResponseBuilders::Hover response_builder, GlobalState global_state, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: (ResponseBuilders::Hover response_builder, GlobalState global_state, URI::Generic uri, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, uri, node_context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         @response_builder = response_builder
         @global_state = global_state
@@ -54,6 +55,7 @@ module RubyLsp
 
         dispatcher.register(
           self,
+          :on_break_node_enter,
           :on_constant_read_node_enter,
           :on_constant_write_node_enter,
           :on_constant_path_node_enter,
@@ -84,8 +86,21 @@ module RubyLsp
         )
       end
 
+      #: (Prism::BreakNode node) -> void
+      def on_break_node_enter(node)
+        handle_keyword_documentation(node.keyword)
+      end
+
       #: (Prism::StringNode node) -> void
       def on_string_node_enter(node)
+        if @path && File.basename(@path) == GEMFILE_NAME
+          call_node = @node_context.call_node
+          if call_node && call_node.name == :gem && call_node.arguments&.arguments&.first == node
+            generate_gem_hover(call_node)
+            return
+          end
+        end
+
         generate_heredoc_hover(node)
       end
 
@@ -96,7 +111,7 @@ module RubyLsp
 
       #: (Prism::ConstantReadNode node) -> void
       def on_constant_read_node_enter(node)
-        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
+        return unless @sorbet_level.ignore?
 
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -106,14 +121,14 @@ module RubyLsp
 
       #: (Prism::ConstantWriteNode node) -> void
       def on_constant_write_node_enter(node)
-        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
+        return unless @sorbet_level.ignore?
 
         generate_hover(node.name.to_s, node.name_loc)
       end
 
       #: (Prism::ConstantPathNode node) -> void
       def on_constant_path_node_enter(node)
-        return if @sorbet_level != RubyDocument::SorbetLevel::Ignore
+        return unless @sorbet_level.ignore?
 
         name = RubyIndexer::Index.constant_name(node)
         return if name.nil?
@@ -123,12 +138,7 @@ module RubyLsp
 
       #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
-        if @path && File.basename(@path) == GEMFILE_NAME && node.name == :gem
-          generate_gem_hover(node)
-          return
-        end
-
-        return if sorbet_level_true_or_higher?(@sorbet_level) && self_receiver?(node)
+        return if @sorbet_level.true_or_higher? && self_receiver?(node)
 
         message = node.message
         return unless message
@@ -273,17 +283,17 @@ module RubyLsp
         content = KEYWORD_DOCS[keyword]
         return unless content
 
-        doc_path = File.join(STATIC_DOCS_PATH, "#{keyword}.md")
+        doc_uri = URI::Generic.from_path(path: File.join(STATIC_DOCS_PATH, "#{keyword}.md"))
 
         @response_builder.push("```ruby\n#{keyword}\n```", category: :title)
-        @response_builder.push("[Read more](#{doc_path})", category: :links)
+        @response_builder.push("[Read more](#{doc_uri})", category: :links)
         @response_builder.push(content, category: :documentation)
       end
 
       #: -> void
       def handle_super_node_hover
         # Sorbet can handle super hover on typed true or higher
-        return if sorbet_level_true_or_higher?(@sorbet_level)
+        return if @sorbet_level.true_or_higher?
 
         surrounding_method = @node_context.surrounding_method
         return unless surrounding_method
@@ -318,7 +328,7 @@ module RubyLsp
       def handle_instance_variable_hover(name)
         # Sorbet enforces that all instance variables be declared on typed strict or higher, which means it will be able
         # to provide all features for them
-        return if @sorbet_level == RubyDocument::SorbetLevel::Strict
+        return if @sorbet_level.strict?
 
         type = @type_inferrer.infer_receiver_type(@node_context)
         return unless type
@@ -366,9 +376,10 @@ module RubyLsp
         # We should only show hover for private constants if the constant is defined in the same namespace as the
         # reference
         first_entry = entries.first #: as !nil
-        return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{name}"
+        full_name = first_entry.name
+        return if first_entry.private? && full_name != "#{@node_context.fully_qualified_name}::#{name}"
 
-        categorized_markdown_from_index_entries(name, entries).each do |category, content|
+        categorized_markdown_from_index_entries(full_name, entries).each do |category, content|
           @response_builder.push(content, category: category)
         end
       end

data/lib/ruby_lsp/listeners/inlay_hints.rb

@@ -8,10 +8,12 @@ module RubyLsp
 
       RESCUE_STRING_LENGTH = "rescue".length #: Integer
 
-      #: (ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint] response_builder, RequestConfig hints_configuration, Prism::Dispatcher dispatcher) -> void
-      def initialize(response_builder, hints_configuration, dispatcher)
+      #: (GlobalState, ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint], Prism::Dispatcher) -> void
+      def initialize(global_state, response_builder, dispatcher)
         @response_builder = response_builder
-        @hints_configuration = hints_configuration
+        @hints_configuration = ( # rubocop:disable Style/RedundantParentheses
+          global_state.feature_configuration(:inlayHint) #: as !nil
+        ) #: RequestConfig
 
         dispatcher.register(self, :on_rescue_node_enter, :on_implicit_node_enter)
       end

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -94,7 +94,7 @@ module RubyLsp
 
       #: (Prism::MatchWriteNode node) -> void
       def on_match_write_node_leave(node)
-        @inside_regex_capture = true if node.call.message == "=~"
+        @inside_regex_capture = false if node.call.message == "=~"
       end
 
       #: (Prism::DefNode node) -> void
@@ -162,7 +162,7 @@ module RubyLsp
 
       #: (Prism::SelfNode node) -> void
       def on_self_node_enter(node)
-        @response_builder.add_token(node.location, :variable, [:default_library])
+        @response_builder.add_token(node.location, :variable, [:defaultLibrary])
       end
 
       #: (Prism::LocalVariableWriteNode node) -> void

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -6,7 +6,7 @@ module RubyLsp
     class SignatureHelp
       include Requests::Support::Common
 
-      #: (ResponseBuilders::SignatureHelp response_builder, GlobalState global_state, NodeContext node_context, Prism::Dispatcher dispatcher, RubyDocument::SorbetLevel sorbet_level) -> void
+      #: (ResponseBuilders::SignatureHelp response_builder, GlobalState global_state, NodeContext node_context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(response_builder, global_state, node_context, dispatcher, sorbet_level)
         @sorbet_level = sorbet_level
         @response_builder = response_builder
@@ -19,7 +19,7 @@ module RubyLsp
 
       #: (Prism::CallNode node) -> void
       def on_call_node_enter(node)
-        return if sorbet_level_true_or_higher?(@sorbet_level)
+        return if @sorbet_level.true_or_higher?
 
         message = node.message
         return unless message