ruby-lsp 0.23.12 → 0.23.13

data/lib/ruby_lsp/document.rb

@@ -21,7 +21,7 @@ module RubyLsp
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
-    EMPTY_CACHE = T.let(Object.new.freeze, Object)
+    EMPTY_CACHE = Object.new.freeze #: Object
 
     abstract!
 
@@ -51,13 +51,13 @@ module RubyLsp
       @source = source
       @version = version
       @global_state = global_state
-      @cache = T.let(Hash.new(EMPTY_CACHE), T::Hash[String, T.untyped])
-      @semantic_tokens = T.let(EMPTY_CACHE, T.any(Interface::SemanticTokens, Object))
-      @encoding = T.let(global_state.encoding, Encoding)
-      @uri = T.let(uri, URI::Generic)
-      @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(T.unsafe(nil), ParseResultType)
-      @last_edit = T.let(nil, T.nilable(Edit))
+      @cache = Hash.new(EMPTY_CACHE) #: Hash[String, untyped]
+      @semantic_tokens = EMPTY_CACHE #: (Interface::SemanticTokens | Object)
+      @encoding = global_state.encoding #: Encoding
+      @uri = uri #: URI::Generic
+      @needs_parsing = true #: bool
+      @parse_result = T.unsafe(nil) #: ParseResultType
+      @last_edit = nil #: Edit?
       parse!
     end
 
@@ -170,15 +170,15 @@ module RubyLsp
     class Scanner
       extend T::Sig
 
-      LINE_BREAK = T.let(0x0A, Integer)
+      LINE_BREAK = 0x0A #: Integer
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
-      SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
+      SURROGATE_PAIR_START = 0xFFFF #: Integer
 
       #: (String source, Encoding encoding) -> void
       def initialize(source, encoding)
-        @current_line = T.let(0, Integer)
-        @pos = T.let(0, Integer)
-        @source = T.let(source.codepoints, T::Array[Integer])
+        @current_line = 0 #: Integer
+        @pos = 0 #: Integer
+        @source = source.codepoints #: Array[Integer]
         @encoding = encoding
       end
 

data/lib/ruby_lsp/erb_document.rb

@@ -17,12 +17,10 @@ module RubyLsp
     def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
-      @host_language_source = T.let("", String)
+      @host_language_source = "" #: String
       super
-      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache =
+        @parse_result.code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
     # @override
@@ -78,10 +76,10 @@ module RubyLsp
       #: (String source) -> void
       def initialize(source)
         @source = source
-        @host_language = T.let(+"", String)
-        @ruby = T.let(+"", String)
-        @current_pos = T.let(0, Integer)
-        @inside_ruby = T.let(false, T::Boolean)
+        @host_language = +"" #: String
+        @ruby = +"" #: String
+        @current_pos = 0 #: Integer
+        @inside_ruby = false #: bool
       end
 
       #: -> void

data/lib/ruby_lsp/global_state.rb

@@ -35,30 +35,27 @@ module RubyLsp
 
     #: -> void
     def initialize
-      @workspace_uri = T.let(URI::Generic.from_path(path: Dir.pwd), URI::Generic)
-      @encoding = T.let(Encoding::UTF_8, Encoding)
-
-      @formatter = T.let("auto", String)
-      @linters = T.let([], T::Array[String])
-      @test_library = T.let("minitest", String)
-      @has_type_checker = T.let(true, T::Boolean)
-      @index = T.let(RubyIndexer::Index.new, RubyIndexer::Index)
-      @supported_formatters = T.let({}, T::Hash[String, Requests::Support::Formatter])
-      @type_inferrer = T.let(TypeInferrer.new(@index), TypeInferrer)
-      @addon_settings = T.let({}, T::Hash[String, T.untyped])
-      @top_level_bundle = T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_gemfile }
-          true
-        rescue Bundler::GemfileNotFound, Bundler::GitError
-          false
-        end,
-        T::Boolean,
-      )
-      @client_capabilities = T.let(ClientCapabilities.new, ClientCapabilities)
-      @enabled_feature_flags = T.let({}, T::Hash[Symbol, T::Boolean])
-      @mutex = T.let(Mutex.new, Mutex)
-      @telemetry_machine_id = T.let(nil, T.nilable(String))
+      @workspace_uri = URI::Generic.from_path(path: Dir.pwd) #: URI::Generic
+      @encoding = Encoding::UTF_8 #: Encoding
+
+      @formatter = "auto" #: String
+      @linters = [] #: Array[String]
+      @test_library = "minitest" #: String
+      @has_type_checker = true #: bool
+      @index = RubyIndexer::Index.new #: RubyIndexer::Index
+      @supported_formatters = {} #: Hash[String, Requests::Support::Formatter]
+      @type_inferrer = TypeInferrer.new(@index) #: TypeInferrer
+      @addon_settings = {} #: Hash[String, untyped]
+      @top_level_bundle = begin
+        Bundler.with_original_env { Bundler.default_gemfile }
+        true
+      rescue Bundler::GemfileNotFound, Bundler::GitError
+        false
+      end #: bool
+      @client_capabilities = ClientCapabilities.new #: ClientCapabilities
+      @enabled_feature_flags = {} #: Hash[Symbol, bool]
+      @mutex = Mutex.new #: Mutex
+      @telemetry_machine_id = nil #: String?
     end
 
     #: [T] { -> T } -> T

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -8,33 +8,30 @@ module RubyLsp
     class CodeLens
       include Requests::Support::Common
 
-      BASE_COMMAND = T.let(
-        begin
-          Bundler.with_original_env { Bundler.default_lockfile }
-          "bundle exec ruby"
-        rescue Bundler::GemfileNotFound
-          "ruby"
-        end,
-        String,
-      )
-      ACCESS_MODIFIERS = T.let([:public, :private, :protected], T::Array[Symbol])
-      SUPPORTED_TEST_LIBRARIES = T.let(["minitest", "test-unit"], T::Array[String])
-      DYNAMIC_REFERENCE_MARKER = T.let("<dynamic_reference>", String)
+      BASE_COMMAND = begin
+        Bundler.with_original_env { Bundler.default_lockfile }
+        "bundle exec ruby"
+      rescue Bundler::GemfileNotFound
+        "ruby"
+      end #: String
+      ACCESS_MODIFIERS = [:public, :private, :protected] #: Array[Symbol]
+      SUPPORTED_TEST_LIBRARIES = ["minitest", "test-unit"] #: Array[String]
+      DYNAMIC_REFERENCE_MARKER = "<dynamic_reference>" #: String
 
       #: (ResponseBuilders::CollectionResponseBuilder[Interface::CodeLens] response_builder, GlobalState global_state, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, global_state, uri, dispatcher)
         @response_builder = response_builder
         @global_state = global_state
-        @uri = T.let(uri, URI::Generic)
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
+        @uri = uri #: URI::Generic
+        @path = uri.to_standardized_path #: String?
         # visibility_stack is a stack of [current_visibility, previous_visibility]
-        @visibility_stack = T.let([[:public, :public]], T::Array[T::Array[T.nilable(Symbol)]])
-        @group_stack = T.let([], T::Array[String])
-        @group_id = T.let(1, Integer)
-        @group_id_stack = T.let([], T::Array[Integer])
+        @visibility_stack = [[:public, :public]] #: Array[Array[Symbol?]]
+        @group_stack = [] #: Array[String]
+        @group_id = 1 #: Integer
+        @group_id_stack = [] #: Array[Integer]
         # We want to avoid adding code lenses for nested definitions
-        @def_depth = T.let(0, Integer)
-        @spec_id = T.let(0, Integer)
+        @def_depth = 0 #: Integer
+        @spec_id = 0 #: Integer
 
         dispatcher.register(
           self,
@@ -219,38 +216,52 @@ module RubyLsp
 
         case @global_state.test_library
         when "minitest"
-          last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
-          command += if last_dynamic_reference_index
-            # In cases where the test path looks like `foo::Bar`
-            # the best we can do is match everything to the right of it.
-            # Tests are classes, dynamic references are only a thing for modules,
-            # so there must be something to the left of the available path.
-            group_stack = T.must(group_stack[last_dynamic_reference_index + 1..])
-            if method_name
-              " --name " + "/::#{Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)}$/"
-            else
-              # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
-              # that are registered on the class itself (matches after `#`) and all tests
-              # that are nested inside of that class in other modules/classes (matches after `::`)
-              " --name " + "\"/::#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
-            end
-          elsif method_name
-            # We know the entire path, do an exact match
-            " --name " + Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)
-          elsif spec_name
-            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}##{Shellwords.escape(spec_name)}$/\""
-          else
-            # Execute all tests of the selected class and tests in
-            # modules/classes nested inside of that class
-            " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
-          end
+          command += generate_minitest_command(group_stack, method_name, spec_name)
         when "test-unit"
-          group_name = T.must(group_stack.last)
-          command += " --testcase " + "/#{Shellwords.escape(group_name)}/"
+          command += generate_test_unit_command(group_stack, method_name)
+        end
+
+        command
+      end
+
+      #: (Array[String] group_stack, String? method_name, String? spec_name) -> String
+      def generate_minitest_command(group_stack, method_name, spec_name)
+        last_dynamic_reference_index = group_stack.rindex(DYNAMIC_REFERENCE_MARKER)
+
+        if last_dynamic_reference_index
+          # In cases where the test path looks like `foo::Bar`
+          # the best we can do is match everything to the right of it.
+          # Tests are classes, dynamic references are only a thing for modules,
+          # so there must be something to the left of the available path.
+          dynamic_stack = T.must(group_stack[last_dynamic_reference_index + 1..])
 
           if method_name
-            command += " --name " + Shellwords.escape(method_name)
+            " --name " + "/::#{Shellwords.escape(dynamic_stack.join("::")) + "#" + Shellwords.escape(method_name)}$/"
+          else
+            # When clicking on a CodeLens for `Test`, `(#|::)` will match all tests
+            # that are registered on the class itself (matches after `#`) and all tests
+            # that are nested inside of that class in other modules/classes (matches after `::`)
+            " --name " + "\"/::#{Shellwords.escape(dynamic_stack.join("::"))}(#|::)/\""
           end
+        elsif method_name
+          # We know the entire path, do an exact match
+          " --name " + Shellwords.escape(group_stack.join("::")) + "#" + Shellwords.escape(method_name)
+        elsif spec_name
+          " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}##{Shellwords.escape(spec_name)}$/\""
+        else
+          # Execute all tests of the selected class and tests in
+          # modules/classes nested inside of that class
+          " --name " + "\"/^#{Shellwords.escape(group_stack.join("::"))}(#|::)/\""
+        end
+      end
+
+      #: (Array[String] group_stack, String? method_name) -> String
+      def generate_test_unit_command(group_stack, method_name)
+        group_name = T.must(group_stack.last)
+        command = " --testcase " + "/#{Shellwords.escape(group_name)}/"
+
+        if method_name
+          command += " --name " + Shellwords.escape(method_name)
         end
 
         command

data/lib/ruby_lsp/listeners/completion.rb

@@ -62,8 +62,8 @@ module RubyLsp
       )
         @response_builder = response_builder
         @global_state = global_state
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @node_context = node_context
         @sorbet_level = sorbet_level
         @uri = uri

data/lib/ruby_lsp/listeners/definition.rb

@@ -12,8 +12,8 @@ module RubyLsp
       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
-        @index = T.let(global_state.index, RubyIndexer::Index)
-        @type_inferrer = T.let(global_state.type_inferrer, TypeInferrer)
+        @index = global_state.index #: RubyIndexer::Index
+        @type_inferrer = global_state.type_inferrer #: TypeInferrer
         @language_id = language_id
         @uri = uri
         @node_context = node_context

data/lib/ruby_lsp/listeners/document_highlight.rb

@@ -6,84 +6,66 @@ module RubyLsp
     class DocumentHighlight
       include Requests::Support::Common
 
-      GLOBAL_VARIABLE_NODES = T.let(
-        [
-          Prism::GlobalVariableAndWriteNode,
-          Prism::GlobalVariableOperatorWriteNode,
-          Prism::GlobalVariableOrWriteNode,
-          Prism::GlobalVariableReadNode,
-          Prism::GlobalVariableTargetNode,
-          Prism::GlobalVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      INSTANCE_VARIABLE_NODES = T.let(
-        [
-          Prism::InstanceVariableAndWriteNode,
-          Prism::InstanceVariableOperatorWriteNode,
-          Prism::InstanceVariableOrWriteNode,
-          Prism::InstanceVariableReadNode,
-          Prism::InstanceVariableTargetNode,
-          Prism::InstanceVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      CONSTANT_NODES = T.let(
-        [
-          Prism::ConstantAndWriteNode,
-          Prism::ConstantOperatorWriteNode,
-          Prism::ConstantOrWriteNode,
-          Prism::ConstantReadNode,
-          Prism::ConstantTargetNode,
-          Prism::ConstantWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      CONSTANT_PATH_NODES = T.let(
-        [
-          Prism::ConstantPathAndWriteNode,
-          Prism::ConstantPathNode,
-          Prism::ConstantPathOperatorWriteNode,
-          Prism::ConstantPathOrWriteNode,
-          Prism::ConstantPathTargetNode,
-          Prism::ConstantPathWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      CLASS_VARIABLE_NODES = T.let(
-        [
-          Prism::ClassVariableAndWriteNode,
-          Prism::ClassVariableOperatorWriteNode,
-          Prism::ClassVariableOrWriteNode,
-          Prism::ClassVariableReadNode,
-          Prism::ClassVariableTargetNode,
-          Prism::ClassVariableWriteNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
-
-      LOCAL_NODES = T.let(
-        [
-          Prism::LocalVariableAndWriteNode,
-          Prism::LocalVariableOperatorWriteNode,
-          Prism::LocalVariableOrWriteNode,
-          Prism::LocalVariableReadNode,
-          Prism::LocalVariableTargetNode,
-          Prism::LocalVariableWriteNode,
-          Prism::BlockParameterNode,
-          Prism::RequiredParameterNode,
-          Prism::RequiredKeywordParameterNode,
-          Prism::OptionalKeywordParameterNode,
-          Prism::RestParameterNode,
-          Prism::OptionalParameterNode,
-          Prism::KeywordRestParameterNode,
-        ],
-        T::Array[T.class_of(Prism::Node)],
-      )
+      GLOBAL_VARIABLE_NODES = [
+        Prism::GlobalVariableAndWriteNode,
+        Prism::GlobalVariableOperatorWriteNode,
+        Prism::GlobalVariableOrWriteNode,
+        Prism::GlobalVariableReadNode,
+        Prism::GlobalVariableTargetNode,
+        Prism::GlobalVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      INSTANCE_VARIABLE_NODES = [
+        Prism::InstanceVariableAndWriteNode,
+        Prism::InstanceVariableOperatorWriteNode,
+        Prism::InstanceVariableOrWriteNode,
+        Prism::InstanceVariableReadNode,
+        Prism::InstanceVariableTargetNode,
+        Prism::InstanceVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      CONSTANT_NODES = [
+        Prism::ConstantAndWriteNode,
+        Prism::ConstantOperatorWriteNode,
+        Prism::ConstantOrWriteNode,
+        Prism::ConstantReadNode,
+        Prism::ConstantTargetNode,
+        Prism::ConstantWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      CONSTANT_PATH_NODES = [
+        Prism::ConstantPathAndWriteNode,
+        Prism::ConstantPathNode,
+        Prism::ConstantPathOperatorWriteNode,
+        Prism::ConstantPathOrWriteNode,
+        Prism::ConstantPathTargetNode,
+        Prism::ConstantPathWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      CLASS_VARIABLE_NODES = [
+        Prism::ClassVariableAndWriteNode,
+        Prism::ClassVariableOperatorWriteNode,
+        Prism::ClassVariableOrWriteNode,
+        Prism::ClassVariableReadNode,
+        Prism::ClassVariableTargetNode,
+        Prism::ClassVariableWriteNode,
+      ] #: Array[singleton(Prism::Node)]
+
+      LOCAL_NODES = [
+        Prism::LocalVariableAndWriteNode,
+        Prism::LocalVariableOperatorWriteNode,
+        Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableReadNode,
+        Prism::LocalVariableTargetNode,
+        Prism::LocalVariableWriteNode,
+        Prism::BlockParameterNode,
+        Prism::RequiredParameterNode,
+        Prism::RequiredKeywordParameterNode,
+        Prism::OptionalKeywordParameterNode,
+        Prism::RestParameterNode,
+        Prism::OptionalParameterNode,
+        Prism::KeywordRestParameterNode,
+      ] #: Array[singleton(Prism::Node)]
 
       #: (ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight] response_builder, Prism::Node? target, Prism::Node? parent, Prism::Dispatcher dispatcher, Hash[Symbol, untyped] position) -> void
       def initialize(response_builder, target, parent, dispatcher, position)
@@ -114,8 +96,8 @@ module RubyLsp
             [target, nil]
           end
 
-        @target = T.let(highlight_target, T.nilable(Prism::Node))
-        @target_value = T.let(highlight_target_value, T.nilable(String))
+        @target = highlight_target #: Prism::Node?
+        @target_value = highlight_target_value #: String?
         @target_position = position
 
         if @target

data/lib/ruby_lsp/listeners/document_link.rb

@@ -8,49 +8,43 @@ module RubyLsp
     class DocumentLink
       include Requests::Support::Common
 
-      GEM_TO_VERSION_MAP = T.let(
-        [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
-          [s.name, s.version.to_s]
-        end.to_h.freeze,
-        T::Hash[String, String],
-      )
+      GEM_TO_VERSION_MAP = [*::Gem::Specification.default_stubs, *::Gem::Specification.stubs].map! do |s|
+        [s.name, s.version.to_s]
+      end.to_h.freeze #: Hash[String, String]
 
       class << self
         #: -> Hash[String, Hash[String, Hash[String, String]]]
         def gem_paths
-          @gem_paths ||= T.let(
-            begin
-              lookup = {}
-
-              Gem::Specification.stubs.each do |stub|
-                spec = stub.to_spec
-                lookup[spec.name] = {}
-                lookup[spec.name][spec.version.to_s] = {}
-
-                Dir.glob("**/*.rb", base: "#{spec.full_gem_path.delete_prefix("//?/")}/").each do |path|
-                  lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
-                end
-              end
+          @gem_paths ||= begin
+            lookup = {}
+
+            Gem::Specification.stubs.each do |stub|
+              spec = stub.to_spec
+              lookup[spec.name] = {}
+              lookup[spec.name][spec.version.to_s] = {}
 
-              Gem::Specification.default_stubs.each do |stub|
-                spec = stub.to_spec
-                lookup[spec.name] = {}
-                lookup[spec.name][spec.version.to_s] = {}
-                prefix_matchers = Regexp.union(spec.require_paths.map do |rp|
-                                                 Regexp.new("^#{rp}/")
-                                               end)
-                prefix_matcher = Regexp.union(prefix_matchers, //)
-
-                spec.files.each do |file|
-                  path = file.sub(prefix_matcher, "")
-                  lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
-                end
+              Dir.glob("**/*.rb", base: "#{spec.full_gem_path.delete_prefix("//?/")}/").each do |path|
+                lookup[spec.name][spec.version.to_s][path] = "#{spec.full_gem_path}/#{path}"
+              end
+            end
+
+            Gem::Specification.default_stubs.each do |stub|
+              spec = stub.to_spec
+              lookup[spec.name] = {}
+              lookup[spec.name][spec.version.to_s] = {}
+              prefix_matchers = Regexp.union(spec.require_paths.map do |rp|
+                                               Regexp.new("^#{rp}/")
+                                             end)
+              prefix_matcher = Regexp.union(prefix_matchers, //)
+
+              spec.files.each do |file|
+                path = file.sub(prefix_matcher, "")
+                lookup[spec.name][spec.version.to_s][path] = "#{RbConfig::CONFIG["rubylibdir"]}/#{path}"
               end
+            end
 
-              lookup
-            end,
-            T.nilable(T::Hash[String, T::Hash[String, T::Hash[String, String]]]),
-          )
+            lookup
+          end #: Hash[String, Hash[String, Hash[String, String]]]?
         end
       end
 
@@ -61,13 +55,10 @@ module RubyLsp
         @response_builder = response_builder
         path = uri.to_standardized_path
         version_match = path ? /(?<=%40)[\d.]+(?=\.rbi$)/.match(path) : nil
-        @gem_version = T.let(version_match && version_match[0], T.nilable(String))
-        @lines_to_comments = T.let(
-          comments.to_h do |comment|
-            [comment.location.end_line, comment]
-          end,
-          T::Hash[Integer, Prism::Comment],
-        )
+        @gem_version = version_match && version_match[0] #: String?
+        @lines_to_comments = comments.to_h do |comment|
+          [comment.location.end_line, comment]
+        end #: Hash[Integer, Prism::Comment]
 
         dispatcher.register(
           self,

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -6,7 +6,7 @@ module RubyLsp
     class DocumentSymbol
       include Requests::Support::Common
 
-      ATTR_ACCESSORS = T.let([:attr_reader, :attr_writer, :attr_accessor].freeze, T::Array[Symbol])
+      ATTR_ACCESSORS = [:attr_reader, :attr_writer, :attr_accessor].freeze #: Array[Symbol]
 
       #: (ResponseBuilders::DocumentSymbol response_builder, URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, uri, dispatcher)

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -9,7 +9,7 @@ module RubyLsp
       #: (ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange] response_builder, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, comments, dispatcher)
         @response_builder = response_builder
-        @requires = T.let([], T::Array[Prism::CallNode])
+        @requires = [] #: Array[Prism::CallNode]
         @comments = comments
 
         dispatcher.register(