ruby-lsp 0.23.12 → 0.23.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b902a160bf7f96c2b65716065887523f5e4d1788e9ba7211a5500513f951d2f
-  data.tar.gz: d2500874ca70ea7aa4df5d1ce2106d16e67143fb5cff87208bdfab36a4b49414
+  metadata.gz: e224f23084eccd6f7b441b6cf6ae2793fb9c73a0045bf36f8c1bbdf2b1f00445
+  data.tar.gz: 581749c8bd2ab362075e49940d364af6a237068e6107d340a2535043d7fdec37
 SHA512:
-  metadata.gz: 5d7d14c58e08d99a9c4f19d2ccde6171da415093c7ebab744181af7ebc8617eae4ba09a992123542d5a5ba44177457cd23cd8bd0ece1886b17237c7bad73fc2b
-  data.tar.gz: eea9a42eeabe3e8c5ce86210770f76e210b313bd94bc457dcfe99fc7a0913e24443b67e35c4c64e46420e95a47cd2cb0eaa7004fbbb8e9544932a90c63686219
+  metadata.gz: a5d7cb45c56ad5e9e92cba7a0012be7a1626044da4fbc936c413b7a8e5cb3cdd4463bf56dd35ef65feed10f0de363edd04702a4496572248e6e74ea9f720a373
+  data.tar.gz: 53639a355c1641e8b11d4e756a417ea9ee96421cb5a87090ffc94cd8f905d41ca3fa5111e4171a81fa62b452c23088895deca0e7eb52fd2e8fed82e1232d2d06

data/VERSION

@@ -1 +1 @@
-0.23.12
+0.23.13

data/lib/rubocop/cop/ruby_lsp/use_language_server_aliases.rb

@@ -29,7 +29,7 @@ module RuboCop
       class UseLanguageServerAliases < RuboCop::Cop::Base
         extend RuboCop::Cop::AutoCorrector
 
-        ALIASED_CONSTANTS = T.let([:Interface, :Transport, :Constant].freeze, T::Array[Symbol])
+        ALIASED_CONSTANTS = [:Interface, :Transport, :Constant].freeze #: Array[Symbol]
 
         MSG = "Use constant alias `%{constant}`."
 

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -3,16 +3,13 @@
 
 module RubyIndexer
   class Configuration
-    CONFIGURATION_SCHEMA = T.let(
-      {
-        "excluded_gems" => Array,
-        "included_gems" => Array,
-        "excluded_patterns" => Array,
-        "included_patterns" => Array,
-        "excluded_magic_comments" => Array,
-      }.freeze,
-      T::Hash[String, T.untyped],
-    )
+    CONFIGURATION_SCHEMA = {
+      "excluded_gems" => Array,
+      "included_gems" => Array,
+      "excluded_patterns" => Array,
+      "included_patterns" => Array,
+      "excluded_magic_comments" => Array,
+    }.freeze #: Hash[String, untyped]
 
     #: String
     attr_writer :workspace_path
@@ -22,18 +19,15 @@ module RubyIndexer
 
     #: -> void
     def initialize
-      @workspace_path = T.let(Dir.pwd, String)
-      @encoding = T.let(Encoding::UTF_8, Encoding)
-      @excluded_gems = T.let(initial_excluded_gems, T::Array[String])
-      @included_gems = T.let([], T::Array[String])
-
-      @excluded_patterns = T.let(
-        [
-          "**/{test,spec}/**/{*_test.rb,test_*.rb,*_spec.rb}",
-          "**/fixtures/**/*",
-        ],
-        T::Array[String],
-      )
+      @workspace_path = Dir.pwd #: String
+      @encoding = Encoding::UTF_8 #: Encoding
+      @excluded_gems = initial_excluded_gems #: Array[String]
+      @included_gems = [] #: Array[String]
+
+      @excluded_patterns = [
+        "**/{test,spec}/**/{*_test.rb,test_*.rb,*_spec.rb}",
+        "**/fixtures/**/*",
+      ] #: Array[String]
 
       path = Bundler.settings["path"]
       if path
@@ -45,23 +39,20 @@ module RubyIndexer
 
       # We start the included patterns with only the non excluded directories so that we can avoid paying the price of
       # traversing large directories that don't include Ruby files like `node_modules`
-      @included_patterns = T.let(["{#{top_level_directories.join(",")}}/**/*.rb", "*.rb"], T::Array[String])
-      @excluded_magic_comments = T.let(
-        [
-          "frozen_string_literal:",
-          "typed:",
-          "compiled:",
-          "encoding:",
-          "shareable_constant_value:",
-          "warn_indent:",
-          "rubocop:",
-          "nodoc:",
-          "doc:",
-          "coding:",
-          "warn_past_scope:",
-        ],
-        T::Array[String],
-      )
+      @included_patterns = ["{#{top_level_directories.join(",")}}/**/*.rb", "*.rb"] #: Array[String]
+      @excluded_magic_comments = [
+        "frozen_string_literal:",
+        "typed:",
+        "compiled:",
+        "encoding:",
+        "shareable_constant_value:",
+        "warn_indent:",
+        "rubocop:",
+        "nodoc:",
+        "doc:",
+        "coding:",
+        "warn_past_scope:",
+      ] #: Array[String]
     end
 
     #: -> Array[URI::Generic]
@@ -177,7 +168,7 @@ module RubyIndexer
 
     #: -> Regexp
     def magic_comment_regex
-      @magic_comment_regex ||= T.let(/^#\s*#{@excluded_magic_comments.join("|")}/, T.nilable(Regexp))
+      @magic_comment_regex ||= /^#\s*#{@excluded_magic_comments.join("|")}/ #: Regexp?
     end
 
     #: (Hash[String, untyped] config) -> void

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -3,8 +3,8 @@
 
 module RubyIndexer
   class DeclarationListener
-    OBJECT_NESTING = T.let(["Object"].freeze, T::Array[String])
-    BASIC_OBJECT_NESTING = T.let(["BasicObject"].freeze, T::Array[String])
+    OBJECT_NESTING = ["Object"].freeze #: Array[String]
+    BASIC_OBJECT_NESTING = ["BasicObject"].freeze #: Array[String]
 
     #: Array[String]
     attr_reader :indexing_errors
@@ -13,28 +13,24 @@ module RubyIndexer
     def initialize(index, dispatcher, parse_result, uri, collect_comments: false)
       @index = index
       @uri = uri
-      @enhancements = T.let(Enhancement.all(self), T::Array[Enhancement])
-      @visibility_stack = T.let([VisibilityScope.public_scope], T::Array[VisibilityScope])
-      @comments_by_line = T.let(
-        parse_result.comments.to_h do |c|
-          [c.location.start_line, c]
-        end,
-        T::Hash[Integer, Prism::Comment],
-      )
-      @inside_def = T.let(false, T::Boolean)
-      @code_units_cache = T.let(
-        parse_result.code_units_cache(@index.configuration.encoding),
-        T.any(T.proc.params(arg0: Integer).returns(Integer), Prism::CodeUnitsCache),
-      )
-      @source_lines = T.let(parse_result.source.lines, T::Array[String])
+      @enhancements = Enhancement.all(self) #: Array[Enhancement]
+      @visibility_stack = [VisibilityScope.public_scope] #: Array[VisibilityScope]
+      @comments_by_line = parse_result.comments.to_h do |c|
+        [c.location.start_line, c]
+      end #: Hash[Integer, Prism::Comment]
+      @inside_def = false #: bool
+      @code_units_cache = parse_result
+        .code_units_cache(@index.configuration.encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
+
+      @source_lines = parse_result.source.lines #: Array[String]
 
       # The nesting stack we're currently inside. Used to determine the fully qualified name of constants, but only
       # stored by unresolved aliases which need the original nesting to be lazily resolved
-      @stack = T.let([], T::Array[String])
+      @stack = [] #: Array[String]
 
       # A stack of namespace entries that represent where we currently are. Used to properly assign methods to an owner
-      @owner_stack = T.let([], T::Array[Entry::Namespace])
-      @indexing_errors = T.let([], T::Array[String])
+      @owner_stack = [] #: Array[Entry::Namespace]
+      @indexing_errors = [] #: Array[String]
       @collect_comments = collect_comments
 
       dispatcher.register(
@@ -269,11 +265,11 @@ module RubyIndexer
       when :include, :prepend, :extend
         handle_module_operation(node, message)
       when :public
-        @visibility_stack.push(VisibilityScope.public_scope)
+        handle_visibility_change(node, Entry::Visibility::PUBLIC)
       when :protected
-        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PROTECTED))
+        handle_visibility_change(node, Entry::Visibility::PROTECTED)
       when :private
-        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
+        handle_visibility_change(node, Entry::Visibility::PRIVATE)
       when :module_function
         handle_module_function(node)
       when :private_class_method
@@ -1038,5 +1034,43 @@ module RubyIndexer
 
       name.split("::").last
     end
+
+    #: (Prism::CallNode, Entry::Visibility) -> void
+    def handle_visibility_change(node, visibility)
+      owner  = @owner_stack.last
+      return unless owner
+
+      owner_name = owner.name
+      method_names = string_or_symbol_argument_values(node)
+
+      if method_names.empty?
+        @visibility_stack.push(VisibilityScope.new(visibility: visibility))
+        return
+      end
+
+      method_names.each do |method_name|
+        entries = @index.resolve_method(method_name, owner_name)
+        next unless entries
+
+        entries.each do |entry|
+          entry.visibility = visibility
+        end
+      end
+    end
+
+    #: (Prism::CallNode) -> Array[String]
+    def string_or_symbol_argument_values(node)
+      arguments = node.arguments&.arguments
+      return [] unless arguments
+
+      arguments.filter_map do |argument|
+        case argument
+        when Prism::StringNode
+          argument.content
+        when Prism::SymbolNode
+          argument.value
+        end
+      end
+    end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/enhancement.rb

@@ -8,7 +8,7 @@ module RubyIndexer
 
     abstract!
 
-    @enhancements = T.let([], T::Array[T::Class[Enhancement]])
+    @enhancements = [] #: Array[Class[Enhancement]]
 
     class << self
       extend T::Sig

data/lib/ruby_indexer/lib/ruby_indexer/entry.rb

@@ -30,7 +30,7 @@ module RubyIndexer
       @name = name
       @uri = uri
       @comments = comments
-      @visibility = T.let(Visibility::PUBLIC, Visibility)
+      @visibility = Visibility::PUBLIC #: Visibility
       @location = location
     end
 
@@ -137,7 +137,7 @@ module RubyIndexer
 
       #: (Array[String] nesting, URI::Generic uri, Location location, Location name_location, String? comments) -> void
       def initialize(nesting, uri, location, name_location, comments)
-        @name = T.let(nesting.join("::"), String)
+        @name = nesting.join("::") #: String
         # The original nesting where this namespace was discovered
         @nesting = nesting
 
@@ -156,7 +156,7 @@ module RubyIndexer
       # and prepended
       #: -> Array[ModuleOperation]
       def mixin_operations
-        @mixin_operations ||= T.let([], T.nilable(T::Array[ModuleOperation]))
+        @mixin_operations ||= [] #: Array[ModuleOperation]?
       end
 
       #: -> Integer
@@ -251,7 +251,7 @@ module RubyIndexer
 
     # A rest method parameter, e.g. `def foo(*a)`
     class RestParameter < Parameter
-      DEFAULT_NAME = T.let(:"<anonymous splat>", Symbol)
+      DEFAULT_NAME = :"<anonymous splat>" #: Symbol
 
       # @override
       #: -> Symbol
@@ -262,7 +262,7 @@ module RubyIndexer
 
     # A keyword rest method parameter, e.g. `def foo(**a)`
     class KeywordRestParameter < Parameter
-      DEFAULT_NAME = T.let(:"<anonymous keyword splat>", Symbol)
+      DEFAULT_NAME = :"<anonymous keyword splat>" #: Symbol
 
       # @override
       #: -> Symbol
@@ -273,7 +273,7 @@ module RubyIndexer
 
     # A block method parameter, e.g. `def foo(&block)`
     class BlockParameter < Parameter
-      DEFAULT_NAME = T.let(:"<anonymous block>", Symbol)
+      DEFAULT_NAME = :"<anonymous block>" #: Symbol
 
       class << self
         #: -> BlockParameter
@@ -343,14 +343,11 @@ module RubyIndexer
       # @override
       #: -> Array[Signature]
       def signatures
-        @signatures ||= T.let(
-          begin
-            params = []
-            params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
-            [Entry::Signature.new(params)]
-          end,
-          T.nilable(T::Array[Signature]),
-        )
+        @signatures ||= begin
+          params = []
+          params << RequiredParameter.new(name: name.delete_suffix("=").to_sym) if name.end_with?("=")
+          [Entry::Signature.new(params)]
+        end #: Array[Signature]?
       end
     end
 
@@ -484,7 +481,7 @@ module RubyIndexer
         )
 
         @target = target
-        @owner = T.let(unresolved_alias.owner, T.nilable(Entry::Namespace))
+        @owner = unresolved_alias.owner #: Entry::Namespace?
       end
 
       #: -> String
@@ -539,10 +536,10 @@ module RubyIndexer
       #: (Array[Prism::Node] arguments) -> bool
       def matches?(arguments)
         min_pos = 0
-        max_pos = T.let(0, T.any(Integer, Float))
+        max_pos = 0 #: (Integer | Float)
         names = []
-        has_forward = T.let(false, T::Boolean)
-        has_keyword_rest = T.let(false, T::Boolean)
+        has_forward = false #: bool
+        has_keyword_rest = false #: bool
 
         @parameters.each do |param|
           case param

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -57,10 +57,10 @@ module RubyIndexer
       #  "Foo" => [#<Entry::Class>, #<Entry::Class>],
       #  "Foo::Bar" => [#<Entry::Class>],
       # }
-      @entries = T.let({}, T::Hash[String, T::Array[Entry]])
+      @entries = {} #: Hash[String, Array[Entry]]
 
       # Holds all entries in the index using a prefix tree for searching based on prefixes to provide autocompletion
-      @entries_tree = T.let(PrefixTree[T::Array[Entry]].new, PrefixTree[T::Array[Entry]])
+      @entries_tree = PrefixTree[T::Array[Entry]].new #: PrefixTree[Array[Entry]]
 
       # Holds references to where entries where discovered so that we can easily delete them
       # {
@@ -68,23 +68,20 @@ module RubyIndexer
       #  "file:///my/project/bar.rb" => [#<Entry::Class>],
       #  "untitled:Untitled-1" => [#<Entry::Class>],
       # }
-      @uris_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])
+      @uris_to_entries = {} #: Hash[String, Array[Entry]]
 
       # Holds all require paths for every indexed item so that we can provide autocomplete for requires
-      @require_paths_tree = T.let(PrefixTree[URI::Generic].new, PrefixTree[URI::Generic])
+      @require_paths_tree = PrefixTree[URI::Generic].new #: PrefixTree[URI::Generic]
 
       # Holds the linearized ancestors list for every namespace
-      @ancestors = T.let({}, T::Hash[String, T::Array[String]])
+      @ancestors = {} #: Hash[String, Array[String]]
 
       # Map of module name to included hooks that have to be executed when we include the given module
-      @included_hooks = T.let(
-        {},
-        T::Hash[String, T::Array[T.proc.params(index: Index, base: Entry::Namespace).void]],
-      )
+      @included_hooks = {} #: Hash[String, Array[^(Index index, Entry::Namespace base) -> void]]
 
-      @configuration = T.let(RubyIndexer::Configuration.new, Configuration)
+      @configuration = RubyIndexer::Configuration.new #: Configuration
 
-      @initial_indexing_completed = T.let(false, T::Boolean)
+      @initial_indexing_completed = false #: bool
     end
 
     # Register an included `hook` that will be executed when `module_name` is included into any namespace

data/lib/ruby_indexer/lib/ruby_indexer/prefix_tree.rb

@@ -39,7 +39,7 @@ module RubyIndexer
 
     #: -> void
     def initialize
-      @root = T.let(Node.new("", ""), Node[Value])
+      @root = Node.new("", "") #: Node[Value]
     end
 
     # Search the PrefixTree based on a given `prefix`. If `foo` is an entry in the tree, then searching for `fo` will
@@ -78,7 +78,7 @@ module RubyIndexer
       return unless node
 
       # Remove the node from the tree and then go up the parents to remove any of them with empty children
-      parent = T.let(T.must(node.parent), T.nilable(Node[Value]))
+      parent = T.must(node.parent) #: Node[Value]?
 
       while parent
         parent.children.delete(node.key)

data/lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb

@@ -3,7 +3,7 @@
 
 module RubyIndexer
   class RBSIndexer
-    HAS_UNTYPED_FUNCTION = T.let(!!defined?(RBS::Types::UntypedFunction), T::Boolean)
+    HAS_UNTYPED_FUNCTION = !!defined?(RBS::Types::UntypedFunction) #: bool
 
     #: (Index index) -> void
     def initialize(index)

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -66,8 +66,8 @@ module RubyIndexer
       @index = index
       @uri = uri
       @include_declarations = include_declarations
-      @stack = T.let([], T::Array[String])
-      @references = T.let([], T::Array[Reference])
+      @stack = [] #: Array[String]
+      @references = [] #: Array[Reference]
 
       dispatcher.register(
         self,

data/lib/ruby_indexer/test/configuration_test.rb

@@ -147,17 +147,26 @@ module RubyIndexer
         uris = @config.indexable_uris
         assert(uris.none? { |uri| uri.full_path.start_with?(File.join(dir, "ignore")) })
 
+        # The regular default gem path is ~/.rubies/3.4.1/lib/ruby/3.4.0
+        # The alternative default gem path is ~/.rubies/3.4.1/lib/ruby/gems/3.4.0
+        # Here part_1 contains ~/.rubies/3.4.1/lib/ruby/ and part_2 contains 3.4.0, so that we can turn it into the
+        # alternative path
+        part_1, part_2 = Pathname.new(RbConfig::CONFIG["rubylibdir"]).split
+        other_default_gem_dir = part_1.join("gems").join(part_2).to_s
+
         # After switching the workspace path, all indexable URIs will be found in one of these places:
         # - The new workspace path
         # - The Ruby LSP's own code (because Bundler is requiring the dependency from source)
         # - Bundled gems
         # - Default gems
+        # - Other default gem directory
         assert(
           uris.all? do |u|
             u.full_path.start_with?(dir) ||
             u.full_path.start_with?(File.join(Dir.pwd, "lib")) ||
             u.full_path.start_with?(Bundler.bundle_path.to_s) ||
-            u.full_path.start_with?(RbConfig::CONFIG["rubylibdir"])
+            u.full_path.start_with?(RbConfig::CONFIG["rubylibdir"]) ||
+            u.full_path.start_with?(other_default_gem_dir)
           end,
         )
       end

data/lib/ruby_indexer/test/method_test.rb

@@ -924,6 +924,32 @@ module RubyIndexer
       RUBY
     end
 
+    def test_changing_visibility_post_definition
+      index(<<~RUBY)
+        class Foo
+          def bar; end
+          private :bar
+
+          def baz; end
+          protected :baz
+
+          private
+          def qux; end
+
+          public :qux
+        end
+      RUBY
+
+      entry = T.must(@index["bar"].first)
+      assert_predicate(entry, :private?)
+
+      entry = T.must(@index["baz"].first)
+      assert_predicate(entry, :protected?)
+
+      entry = T.must(@index["qux"].first)
+      assert_predicate(entry, :public?)
+    end
+
     private
 
     #: (Entry::Method entry, String call_string) -> void

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -359,7 +359,7 @@ module RubyIndexer
       assert_equal("all?", entry.old_name)
       assert_equal("Array", entry.owner.name)
       assert(entry.file_path.end_with?("core/array.rbs"))
-      assert_includes(entry.comments, "Returns `true` if any element of `self` meets a given criterion.")
+      refute_empty(entry.comments)
     end
 
     def test_indexing_untyped_functions

data/lib/ruby_lsp/addon.rb

@@ -25,10 +25,10 @@ module RubyLsp
 
     abstract!
 
-    @addons = T.let([], T::Array[Addon])
-    @addon_classes = T.let([], T::Array[T.class_of(Addon)])
+    @addons = [] #: Array[Addon]
+    @addon_classes = [] #: Array[singleton(Addon)]
     # Add-on instances that have declared a handler to accept file watcher events
-    @file_watcher_addons = T.let([], T::Array[Addon])
+    @file_watcher_addons = [] #: Array[Addon]
 
     AddonNotFoundError = Class.new(StandardError)
 
@@ -149,7 +149,7 @@ module RubyLsp
 
     #: -> void
     def initialize
-      @errors = T.let([], T::Array[StandardError])
+      @errors = [] #: Array[StandardError]
     end
 
     #: (StandardError error) -> self
@@ -236,5 +236,13 @@ module RubyLsp
     # @overridable
     #: (ResponseBuilders::TestCollection response_builder, Prism::Dispatcher dispatcher, URI::Generic uri) -> void
     def create_discover_tests_listener(response_builder, dispatcher, uri); end
+
+    # Resolves the minimal set of commands required to execute the requested tests. Add-ons are responsible for only
+    # handling items related to the framework they add support for and have discovered themselves
+    # @overridable
+    #: (Array[Hash[Symbol, untyped]]) -> Array[String]
+    def resolve_test_commands(items)
+      []
+    end
   end
 end

data/lib/ruby_lsp/base_server.rb

@@ -10,28 +10,25 @@ module RubyLsp
 
     #: (**untyped options) -> void
     def initialize(**options)
-      @test_mode = T.let(options[:test_mode], T.nilable(T::Boolean))
-      @setup_error = T.let(options[:setup_error], T.nilable(StandardError))
-      @install_error = T.let(options[:install_error], T.nilable(StandardError))
-      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
-      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
-      @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
-      @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
-      @cancelled_requests = T.let([], T::Array[Integer])
-      @worker = T.let(new_worker, Thread)
-      @current_request_id = T.let(1, Integer)
-      @global_state = T.let(GlobalState.new, GlobalState)
-      @store = T.let(Store.new(@global_state), Store)
-      @outgoing_dispatcher = T.let(
-        Thread.new do
-          unless @test_mode
-            while (message = @outgoing_queue.pop)
-              @global_state.synchronize { @writer.write(message.to_hash) }
-            end
+      @test_mode = options[:test_mode] #: bool?
+      @setup_error = options[:setup_error] #: StandardError?
+      @install_error = options[:install_error] #: StandardError?
+      @writer = Transport::Stdio::Writer.new #: Transport::Stdio::Writer
+      @reader = Transport::Stdio::Reader.new #: Transport::Stdio::Reader
+      @incoming_queue = Thread::Queue.new #: Thread::Queue
+      @outgoing_queue = Thread::Queue.new #: Thread::Queue
+      @cancelled_requests = [] #: Array[Integer]
+      @worker = new_worker #: Thread
+      @current_request_id = 1 #: Integer
+      @global_state = GlobalState.new #: GlobalState
+      @store = Store.new(@global_state) #: Store
+      @outgoing_dispatcher = Thread.new do
+        unless @test_mode
+          while (message = @outgoing_queue.pop)
+            @global_state.synchronize { @writer.write(message.to_hash) }
           end
-        end,
-        Thread,
-      )
+        end
+      end #: Thread
 
       Thread.main.priority = 1
 
@@ -148,7 +145,7 @@ module RubyLsp
     #: -> Thread
     def new_worker
       Thread.new do
-        while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
+        while (message = @incoming_queue.pop)
           id = message[:id]
 
           # Check if the request was cancelled before trying to process it

data/lib/ruby_lsp/client_capabilities.rb

@@ -16,24 +16,24 @@ module RubyLsp
     def initialize
       # The editor supports watching files. This requires two capabilities: dynamic registration and relative pattern
       # support
-      @supports_watching_files = T.let(false, T::Boolean)
+      @supports_watching_files = false #: bool
 
       # The editor supports request delegation. This is an experimental capability since request delegation has not been
       # standardized into the LSP spec yet
-      @supports_request_delegation = T.let(false, T::Boolean)
+      @supports_request_delegation = false #: bool
 
       # The editor supports extra arbitrary properties for `window/showMessageRequest`. Necessary for add-ons to show
       # dialogs with user interactions
-      @window_show_message_supports_extra_properties = T.let(false, T::Boolean)
+      @window_show_message_supports_extra_properties = false #: bool
 
       # Which resource operations the editor supports, like renaming files
-      @supported_resource_operations = T.let([], T::Array[String])
+      @supported_resource_operations = [] #: Array[String]
 
       # The editor supports displaying progress requests
-      @supports_progress = T.let(false, T::Boolean)
+      @supports_progress = false #: bool
 
       # The editor supports server initiated refresh for diagnostics
-      @supports_diagnostic_refresh = T.let(false, T::Boolean)
+      @supports_diagnostic_refresh = false #: bool
     end
 
     #: (Hash[Symbol, untyped] capabilities) -> void