ruby-lsp 0.23.14 → 0.23.16

data/lib/ruby_indexer/test/rbs_indexer_test.rb

@@ -6,16 +6,16 @@ require_relative "test_case"
 module RubyIndexer
   class RBSIndexerTest < TestCase
     def test_index_core_classes
-      entries = @index["Array"]
+      entries = @index["Array"] #: as !nil
       refute_nil(entries)
       # Array is a class but also an instance method on Kernel
       assert_equal(2, entries.length)
-      entry = entries.find { |entry| entry.is_a?(RubyIndexer::Entry::Class) }
+      entry = entries.find { |entry| entry.is_a?(Entry::Class) } #: as Entry::Class
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
       assert_equal("Object", entry.parent_class)
       assert_equal(1, entry.mixin_operations.length)
-      enumerable_include = entry.mixin_operations.first
+      enumerable_include = entry.mixin_operations.first #: as !nil
       assert_equal("Enumerable", enumerable_include.module_name)
 
       # Using fixed positions would be fragile, so let's just check some basics.
@@ -26,10 +26,10 @@ module RubyIndexer
     end
 
     def test_index_core_modules
-      entries = @index["Kernel"]
+      entries = @index["Kernel"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
-      entry = entries.first
+      entry = entries.first #: as Entry::Module
       assert_match(%r{/gems/rbs-.*/core/kernel.rbs}, entry.file_path)
       assert_equal("kernel.rbs", entry.file_name)
 
@@ -41,30 +41,23 @@ module RubyIndexer
     end
 
     def test_index_core_constants
-      entries = @index["RUBY_VERSION"]
+      entries = @index["RUBY_VERSION"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
 
-      # Complex::I is defined as `Complex::I = ...`
-      entries = @index["Complex::I"]
+      entries = @index["Complex::I"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
 
-      # Encoding::US_ASCII is defined as
-      # ```
-      # module Encoding
-      #   US_ASCII = ...
-      #   ...
-      # ````
-      entries = @index["Encoding::US_ASCII"]
+      entries = @index["Encoding::US_ASCII"] #: as !nil
       refute_nil(entries)
       assert_equal(1, entries.length)
     end
 
     def test_index_methods
-      entries = @index["initialize"]
+      entries = @index["initialize"] #: as Array[Entry::Method]
       refute_nil(entries)
-      entry = entries.find { |entry| entry.owner.name == "Array" }
+      entry = entries.find { |entry| entry.owner&.name == "Array" } #: as Entry::Method
       assert_match(%r{/gems/rbs-.*/core/array.rbs}, entry.file_path)
       assert_equal("array.rbs", entry.file_name)
       assert_equal(Entry::Visibility::PUBLIC, entry.visibility)
@@ -77,11 +70,11 @@ module RubyIndexer
     end
 
     def test_index_global_declaration
-      entries = @index["$DEBUG"]
+      entries = @index["$DEBUG"] #: as Array[Entry::GlobalVariable]
       refute_nil(entries)
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::GlobalVariable
 
       assert_instance_of(Entry::GlobalVariable, entry)
       assert_equal("$DEBUG", entry.name)
@@ -91,10 +84,10 @@ module RubyIndexer
     end
 
     def test_attaches_correct_owner_to_singleton_methods
-      entries = @index["basename"]
+      entries = @index["basename"] #: as Array[Entry::Method]
       refute_nil(entries)
 
-      owner = entries.first.owner
+      owner = entries.first&.owner #: as Entry::SingletonClass
       assert_instance_of(Entry::SingletonClass, owner)
       assert_equal("File::<Class:File>", owner.name)
     end
@@ -103,47 +96,47 @@ module RubyIndexer
       # NOTE: RBS does not store the name location for classes, modules or methods. This behavior is not exactly what
       # we would like, but for now we assign the same location to both
 
-      entries = @index["Array"]
+      entries = @index["Array"] #: as Array[Entry::Class]
       refute_nil(entries)
-      entry = entries.find { |entry| entry.is_a?(Entry::Class) }
+      entry = entries.find { |entry| entry.is_a?(Entry::Class) } #: as Entry::Class
 
       assert_same(entry.location, entry.name_location)
     end
 
     def test_rbs_method_with_required_positionals
-      entries = @index["crypt"]
+      entries = @index["crypt"] #: as Array[Entry::Method]
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::Method
       signatures = entry.signatures
       assert_equal(1, signatures.length)
 
-      first_signature = signatures.first
+      first_signature = signatures.first #: as Entry::Signature
 
       # (::string salt_str) -> ::String
 
       assert_equal(1, first_signature.parameters.length)
       assert_kind_of(Entry::RequiredParameter, first_signature.parameters[0])
-      assert_equal(:salt_str, first_signature.parameters[0].name)
+      assert_equal(:salt_str, first_signature.parameters[0]&.name)
     end
 
     def test_rbs_method_with_unnamed_required_positionals
-      entries = @index["try_convert"]
-      entry = entries.find { |entry| entry.owner.name == "Array::<Class:Array>" }
+      entries = @index["try_convert"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "Array::<Class:Array>" } #: as Entry::Method
 
-      parameters = entry.signatures[0].parameters
+      parameters = entry.signatures[0]&.parameters #: as Array[Entry::Parameter]
 
       assert_equal([:arg0], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
     end
 
     def test_rbs_method_with_optional_positionals
-      entries = @index["polar"]
-      entry = entries.find { |entry| entry.owner.name == "Complex::<Class:Complex>" }
+      entries = @index["polar"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "Complex::<Class:Complex>" } #: as Entry::Method
 
       # def self.polar: (Numeric, ?Numeric) -> Complex
 
-      parameters = entry.signatures[0].parameters
+      parameters = entry.signatures[0]&.parameters #: as Array[Entry::Parameter]
 
       assert_equal([:arg0, :arg1], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
@@ -151,27 +144,27 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_optional_parameter
-      entries = @index["chomp"]
+      entries = @index["chomp"] #: as Array[Entry::Method]
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::Method
       signatures = entry.signatures
       assert_equal(1, signatures.length)
 
-      first_signature = signatures.first
+      first_signature = signatures.first #: as Entry::Signature
 
       # (?::string? separator) -> ::String
 
       assert_equal(1, first_signature.parameters.length)
       assert_kind_of(Entry::OptionalParameter, first_signature.parameters[0])
-      assert_equal(:separator, first_signature.parameters[0].name)
+      assert_equal(:separator, first_signature.parameters[0]&.name)
     end
 
     def test_rbs_method_with_required_and_optional_parameters
-      entries = @index["gsub"]
+      entries = @index["gsub"] #: as Array[Entry::Method]
       assert_equal(1, entries.length)
 
-      entry = entries.first
+      entry = entries.first #: as Entry::Method
 
       signatures = entry.signatures
       assert_equal(3, signatures.length)
@@ -180,37 +173,37 @@ module RubyIndexer
       # | (::Regexp | ::string pattern) -> ::Enumerator[::String, ::String]
       # | (::Regexp | ::string pattern) { (::String match) -> ::_ToS } -> ::String
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:pattern, :replacement], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::RequiredParameter, parameters[1])
 
-      parameters = signatures[1].parameters
+      parameters = signatures[1]&.parameters #: as !nil
       assert_equal([:pattern], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
 
-      parameters = signatures[2].parameters
+      parameters = signatures[2]&.parameters #: as !nil
       assert_equal([:pattern, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::BlockParameter, parameters[1])
     end
 
     def test_rbs_anonymous_block_parameter
-      entries = @index["open"]
-      entry = entries.find { |entry| entry.owner.name == "File::<Class:File>" }
+      entries = @index["open"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "File::<Class:File>" } #: as Entry::Method
 
       assert_equal(2, entry.signatures.length)
 
       # (::String name, ?::String mode, ?::Integer perm) -> ::IO?
       # | [T] (::String name, ?::String mode, ?::Integer perm) { (::IO) -> T } -> T
 
-      parameters = entry.signatures[0].parameters
+      parameters = entry.signatures[0]&.parameters #: as !nil
       assert_equal([:file_name, :mode, :perm], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
       assert_kind_of(Entry::OptionalParameter, parameters[2])
 
-      parameters = entry.signatures[1].parameters
+      parameters = entry.signatures[1]&.parameters #: as !nil
       assert_equal([:file_name, :mode, :perm, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
@@ -219,10 +212,10 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_rest_positionals
-      entries = @index["count"]
-      entry = entries.find { |entry| entry.owner.name == "String" }
+      entries = @index["count"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "String" } #: as Entry::Method
 
-      parameters = entry.signatures.first.parameters
+      parameters = entry.signatures.first&.parameters #: as !nil
       assert_equal(1, entry.signatures.length)
 
       # (::String::selector selector_0, *::String::selector more_selectors) -> ::Integer
@@ -233,8 +226,8 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_trailing_positionals
-      entries = @index["select"] # https://ruby-doc.org/3.3.3/IO.html#method-c-select
-      entry = entries.find { |entry| entry.owner.name == "IO::<Class:IO>" }
+      entries = @index["select"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "IO::<Class:IO>" } #: as !nil
 
       signatures = entry.signatures
       assert_equal(2, signatures.length)
@@ -242,13 +235,13 @@ module RubyIndexer
       # def self.select: [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array) -> [ Array[X], Array[Y], Array[Z] ] # rubocop:disable Layout/LineLength
       #   | [X, Y, Z] (::Array[X & io]? read_array, ?::Array[Y & io]? write_array, ?::Array[Z & io]? error_array, Time::_Timeout? timeout) -> [ Array[X], Array[Y], Array[Z] ]? # rubocop:disable Layout/LineLength
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
       assert_kind_of(Entry::OptionalParameter, parameters[2])
 
-      parameters = signatures[1].parameters
+      parameters = signatures[1]&.parameters #: as !nil
       assert_equal([:read_array, :write_array, :error_array, :timeout], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
@@ -257,8 +250,8 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_optional_keywords
-      entries = @index["step"]
-      entry = entries.find { |entry| entry.owner.name == "Numeric" }
+      entries = @index["step"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "Numeric" } #: as !nil
 
       signatures = entry.signatures
       assert_equal(4, signatures.length)
@@ -268,24 +261,24 @@ module RubyIndexer
       # | (?by: ::Numeric, ?to: ::Numeric) { (::Numeric) -> void } -> self
       # | (?by: ::Numeric, ?to: ::Numeric) -> ::Enumerator[::Numeric, self]
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:limit, :step, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::OptionalParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
       assert_kind_of(Entry::BlockParameter, parameters[2])
 
-      parameters = signatures[1].parameters
+      parameters = signatures[1]&.parameters #: as !nil
       assert_equal([:limit, :step], parameters.map(&:name))
       assert_kind_of(Entry::OptionalParameter, parameters[0])
       assert_kind_of(Entry::OptionalParameter, parameters[1])
 
-      parameters = signatures[2].parameters
+      parameters = signatures[2]&.parameters #: as !nil
       assert_equal([:by, :to, :"<anonymous block>"], parameters.map(&:name))
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
       assert_kind_of(Entry::BlockParameter, parameters[2])
 
-      parameters = signatures[3].parameters
+      parameters = signatures[3]&.parameters #: as !nil
       assert_equal([:by, :to], parameters.map(&:name))
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[0])
       assert_kind_of(Entry::OptionalKeywordParameter, parameters[1])
@@ -308,14 +301,14 @@ module RubyIndexer
     end
 
     def test_rbs_method_with_rest_keywords
-      entries = @index["method_missing"]
-      entry = entries.find { |entry| entry.owner.name == "BasicObject" }
+      entries = @index["method_missing"] #: as Array[Entry::Method]
+      entry = entries.find { |entry| entry.owner&.name == "BasicObject" } #: as !nil
       signatures = entry.signatures
       assert_equal(1, signatures.length)
 
       # (Symbol, *untyped, **untyped) ?{ (*untyped, **untyped) -> untyped } -> untyped
 
-      parameters = signatures[0].parameters
+      parameters = signatures[0]&.parameters #: as !nil
       assert_equal([:arg0, :"<anonymous splat>", :"<anonymous keyword splat>"], parameters.map(&:name))
       assert_kind_of(Entry::RequiredParameter, parameters[0])
       assert_kind_of(Entry::RestParameter, parameters[1])
@@ -348,24 +341,24 @@ module RubyIndexer
     def test_signature_alias
       # In RBS, an alias means that two methods have the same signature.
       # It does not mean the same thing as a Ruby alias.
-      any_entries = @index["any?"]
+      any_entries = @index["any?"] #: as Array[Entry::UnresolvedMethodAlias]
 
-      assert_equal(["Array", "Enumerable", "Hash"], any_entries.map { _1.owner.name })
+      assert_equal(["Array", "Enumerable", "Hash"], any_entries.map { _1.owner&.name })
 
-      entry = any_entries.find { |entry| entry.owner.name == "Array" }
+      entry = any_entries.find { |entry| entry.owner&.name == "Array" } #: as !nil
 
       assert_kind_of(RubyIndexer::Entry::UnresolvedMethodAlias, entry)
       assert_equal("any?", entry.name)
       assert_equal("all?", entry.old_name)
-      assert_equal("Array", entry.owner.name)
-      assert(entry.file_path.end_with?("core/array.rbs"))
+      assert_equal("Array", entry.owner&.name)
+      assert(entry.file_path&.end_with?("core/array.rbs"))
       refute_empty(entry.comments)
     end
 
     def test_indexing_untyped_functions
-      entries = @index.resolve_method("call", "Method")
+      entries = @index.resolve_method("call", "Method") #: as Array[Entry::Method]
 
-      parameters = entries.first.signatures.first.parameters
+      parameters = entries.first&.signatures&.first&.parameters #: as !nil
       assert_equal(1, parameters.length)
       assert_instance_of(Entry::ForwardingParameter, parameters.first)
     end
@@ -379,7 +372,8 @@ module RubyIndexer
       indexer = RubyIndexer::RBSIndexer.new(index)
       pathname = Pathname.new("/file.rbs")
       indexer.process_signature(pathname, declarations)
-      entry = T.must(index[method_name]).first
+      entry = index[method_name] #: as !nil
+        .first
       T.cast(entry, Entry::Method).signatures
     end
   end

data/lib/ruby_indexer/test/test_case.rb

@@ -18,11 +18,11 @@ module RubyIndexer
     end
 
     def assert_entry(expected_name, type, expected_location, visibility: nil)
-      entries = @index[expected_name]
+      entries = @index[expected_name] #: as !nil
       refute_nil(entries, "Expected #{expected_name} to be indexed")
       refute_empty(entries, "Expected #{expected_name} to be indexed")
 
-      entry = entries.first
+      entry = entries.first #: as !nil
       assert_instance_of(type, entry, "Expected #{expected_name} to be a #{type}")
 
       location = entry.location

data/lib/ruby_lsp/document.rb

@@ -56,8 +56,13 @@ module RubyLsp
       @encoding = global_state.encoding #: Encoding
       @uri = uri #: URI::Generic
       @needs_parsing = true #: bool
-      @parse_result = T.unsafe(nil) #: ParseResultType
       @last_edit = nil #: Edit?
+
+      # Workaround to be able to type parse_result properly. It is immediately set when invoking parse!
+      @parse_result = ( # rubocop:disable Style/RedundantParentheses
+        nil #: as untyped
+      ) #: ParseResultType
+
       parse!
     end
 

data/lib/ruby_lsp/erb_document.rb

@@ -111,7 +111,9 @@ module RubyLsp
               push_char(" ")
             end
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "-"
           if @inside_ruby && next_char == "%" &&
@@ -120,7 +122,9 @@ module RubyLsp
             push_char("   ")
             @inside_ruby = false
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "%"
           if @inside_ruby && next_char == ">"
@@ -128,7 +132,9 @@ module RubyLsp
             @current_pos += 1
             push_char("  ")
           else
-            push_char(T.must(char))
+            push_char(
+              char, #: as !nil
+            )
           end
         when "\r"
           @ruby << char
@@ -143,7 +149,9 @@ module RubyLsp
           @ruby << char
           @host_language << char
         else
-          push_char(T.must(char))
+          push_char(
+            char, #: as !nil
+          )
         end
       end
 

data/lib/ruby_lsp/global_state.rb

@@ -185,7 +185,7 @@ module RubyLsp
 
     #: -> String
     def workspace_path
-      T.must(@workspace_uri.to_standardized_path)
+      @workspace_uri.to_standardized_path #: as !nil
     end
 
     #: -> String

data/lib/ruby_lsp/listeners/code_lens.rb

@@ -208,7 +208,7 @@ module RubyLsp
 
       #: (?group_stack: Array[String], ?spec_name: String?, ?method_name: String?) -> String
       def generate_test_command(group_stack: [], spec_name: nil, method_name: nil)
-        path = T.must(@path)
+        path = @path #: as !nil
         command = BASE_COMMAND
         command += " -Itest" if File.fnmatch?("**/test/**/*", path, File::FNM_PATHNAME)
         command += " -Ispec" if File.fnmatch?("**/spec/**/*", path, File::FNM_PATHNAME)
@@ -233,7 +233,7 @@ module RubyLsp
           # 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..])
+          dynamic_stack = group_stack[last_dynamic_reference_index + 1..] #: as !nil
 
           if method_name
             " --name " + "/::#{Shellwords.escape(dynamic_stack.join("::")) + "#" + Shellwords.escape(method_name)}$/"
@@ -257,7 +257,7 @@ module RubyLsp
 
       #: (Array[String] group_stack, String? method_name) -> String
       def generate_test_unit_command(group_stack, method_name)
-        group_name = T.must(group_stack.last)
+        group_name = group_stack.last #: as !nil
         command = " --testcase " + "/#{Shellwords.escape(group_name)}/"
 
         if method_name

data/lib/ruby_lsp/listeners/completion.rb

@@ -108,7 +108,8 @@ module RubyLsp
         range = range_from_location(node.location)
         candidates = @index.constant_completion_candidates(name, @node_context.nesting)
         candidates.each do |entries|
-          complete_name = T.must(entries.first).name
+          complete_name = entries.first #: as !nil
+            .name
           @response_builder << build_entry_completion(
             complete_name,
             name,
@@ -155,7 +156,7 @@ module RubyLsp
 
             if name
               start_loc = node.location
-              end_loc = T.must(node.call_operator_loc)
+              end_loc = node.call_operator_loc #: as !nil
 
               constant_path_completion(
                 "#{name}::",
@@ -296,7 +297,9 @@ module RubyLsp
         namespace_entries = @index.resolve(aliased_namespace, nesting)
         return unless namespace_entries
 
-        real_namespace = @index.follow_aliased_namespace(T.must(namespace_entries.first).name)
+        namespace_name = namespace_entries.first #: as !nil
+          .name
+        real_namespace = @index.follow_aliased_namespace(namespace_name)
 
         candidates = @index.constant_completion_candidates(
           "#{real_namespace}::#{incomplete_name}",
@@ -305,7 +308,7 @@ module RubyLsp
         candidates.each do |entries|
           # The only time we may have a private constant reference from outside of the namespace is if we're dealing
           # with ConstantPath and the entry name doesn't start with the current nesting
-          first_entry = T.must(entries.first)
+          first_entry = entries.first #: as !nil
           next if first_entry.private? && !first_entry.name.start_with?("#{nesting}::")
 
           entry_name = first_entry.name
@@ -324,7 +327,7 @@ module RubyLsp
             name,
             range,
             entries,
-            top_level_reference || top_level?(T.must(entries.first).name),
+            top_level_reference || top_level?(first_entry.name),
           )
         end
       end
@@ -429,7 +432,10 @@ module RubyLsp
         matched_uris = @index.search_require_paths(path_node_to_complete.content)
 
         matched_uris.map!(&:require_path).sort!.each do |path|
-          @response_builder << build_completion(T.must(path), path_node_to_complete)
+          @response_builder << build_completion(
+            path, #: as !nil
+            path_node_to_complete,
+          )
         end
       end
 
@@ -486,7 +492,9 @@ module RubyLsp
         method_name = @trigger_character == "." ? nil : name
 
         range = if method_name
-          range_from_location(T.must(node.message_loc))
+          range_from_location(
+            node.message_loc, #: as !nil
+          )
         else
           loc = node.call_operator_loc
 
@@ -531,7 +539,9 @@ module RubyLsp
 
       #: (Prism::CallNode node, String name) -> void
       def add_local_completions(node, name)
-        range = range_from_location(T.must(node.message_loc))
+        range = range_from_location(
+          node.message_loc, #: as !nil
+        )
 
         @node_context.locals_for_scope.each do |local|
           local_name = local.to_s
@@ -551,7 +561,9 @@ module RubyLsp
 
       #: (Prism::CallNode node, String name) -> void
       def add_keyword_completions(node, name)
-        range = range_from_location(T.must(node.message_loc))
+        range = range_from_location(
+          node.message_loc, #: as !nil
+        )
 
         KEYWORDS.each do |keyword|
           next unless keyword.start_with?(name)
@@ -584,7 +596,7 @@ module RubyLsp
 
       #: (String real_name, String incomplete_name, Interface::Range range, Array[RubyIndexer::Entry] entries, bool top_level) -> Interface::CompletionItem
       def build_entry_completion(real_name, incomplete_name, range, entries, top_level)
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
         kind = case first_entry
         when RubyIndexer::Entry::Class
           Constant::CompletionItemKind::CLASS
@@ -675,7 +687,8 @@ module RubyLsp
       def top_level?(entry_name)
         nesting = @node_context.nesting
         nesting.length.downto(0) do |i|
-          prefix = T.must(nesting[0...i]).join("::")
+          prefix = nesting[0...i] #: as !nil
+            .join("::")
           full_name = prefix.empty? ? entry_name : "#{prefix}::#{entry_name}"
           next if full_name == entry_name
 

data/lib/ruby_lsp/listeners/definition.rb

@@ -382,7 +382,7 @@ module RubyLsp
 
         # We should only allow jumping to the definition of private constants if the constant is defined in the same
         # namespace as the reference
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
         return if first_entry.private? && first_entry.name != "#{@node_context.fully_qualified_name}::#{value}"
 
         entries.each do |entry|

data/lib/ruby_lsp/listeners/document_link.rb

@@ -107,7 +107,9 @@ module RubyLsp
 
         uri = T.cast(
           begin
-            URI(T.must(match[0]))
+            URI(
+              match[0], #: as !nil
+            )
           rescue URI::Error
             nil
           end,

data/lib/ruby_lsp/listeners/document_symbol.rb

@@ -318,7 +318,7 @@ module RubyLsp
           name: name,
           kind: Constant::SymbolKind::METHOD,
           range_location: new_name_node.location,
-          selection_range_location: T.must(new_name_node.value_loc),
+          selection_range_location: new_name_node.value_loc, #: as !nil
         )
       end
 
@@ -357,7 +357,7 @@ module RubyLsp
               name: name,
               kind: Constant::SymbolKind::FIELD,
               range_location: argument.location,
-              selection_range_location: T.must(argument.value_loc),
+              selection_range_location: argument.value_loc, #: as !nil
             )
           elsif argument.is_a?(Prism::StringNode)
             name = argument.content
@@ -391,7 +391,7 @@ module RubyLsp
             name: name,
             kind: Constant::SymbolKind::METHOD,
             range_location: new_name_argument.location,
-            selection_range_location: T.must(new_name_argument.value_loc),
+            selection_range_location: new_name_argument.value_loc, #: as !nil
           )
         elsif new_name_argument.is_a?(Prism::StringNode)
           name = new_name_argument.content

data/lib/ruby_lsp/listeners/folding_ranges.rb

@@ -193,8 +193,10 @@ module RubyLsp
           next if chunk.length == 1
 
           @response_builder << Interface::FoldingRange.new(
-            start_line: T.must(chunk.first).location.start_line - 1,
-            end_line: T.must(chunk.last).location.end_line - 1,
+            start_line: chunk.first #: as !nil
+              .location.start_line - 1,
+            end_line: chunk.last #: as !nil
+              .location.end_line - 1,
             kind: "comment",
           )
         end
@@ -204,8 +206,10 @@ module RubyLsp
       def emit_requires_range
         if @requires.length > 1
           @response_builder << Interface::FoldingRange.new(
-            start_line: T.must(@requires.first).location.start_line - 1,
-            end_line: T.must(@requires.last).location.end_line - 1,
+            start_line: @requires.first #: as !nil
+              .location.start_line - 1,
+            end_line: @requires.last #: as !nil
+              .location.end_line - 1,
             kind: "imports",
           )
         end