ruby-lsp 0.23.14 → 0.23.16

data/lib/ruby_lsp/listeners/hover.rb

@@ -299,7 +299,7 @@ module RubyLsp
         methods = @index.resolve_method(message, type.name, inherited_only: inherited_only)
         return unless methods
 
-        first_method = T.must(methods.first)
+        first_method = methods.first #: as !nil
 
         title = "#{message}#{first_method.decorated_parameters}"
         title << first_method.formatted_signatures
@@ -365,7 +365,7 @@ module RubyLsp
 
         # We should only show hover for 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}::#{name}"
 
         categorized_markdown_from_index_entries(name, entries).each do |category, content|

data/lib/ruby_lsp/listeners/semantic_highlighting.rb

@@ -67,12 +67,18 @@ module RubyLsp
         return if special_method?(message)
 
         if Requests::Support::Sorbet.annotation?(node)
-          @response_builder.add_token(T.must(node.message_loc), :type)
+          @response_builder.add_token(
+            node.message_loc, #: as !nil
+            :type,
+          )
         elsif !node.receiver && !node.opening_loc
           # If the node has a receiver, then the syntax is not ambiguous and semantic highlighting is not necessary to
           # determine that the token is a method call. The only ambiguous case is method calls with implicit self
           # receiver and no parenthesis, which may be confused with local variables
-          @response_builder.add_token(T.must(node.message_loc), :method)
+          @response_builder.add_token(
+            node.message_loc, #: as !nil
+            :method,
+          )
         end
       end
 
@@ -98,7 +104,7 @@ module RubyLsp
 
       #: (Prism::DefNode node) -> void
       def on_def_node_leave(node)
-        @current_scope = T.must(@current_scope.parent)
+        @current_scope = @current_scope.parent #: as !nil
       end
 
       #: (Prism::BlockNode node) -> void
@@ -108,7 +114,7 @@ module RubyLsp
 
       #: (Prism::BlockNode node) -> void
       def on_block_node_leave(node)
-        @current_scope = T.must(@current_scope.parent)
+        @current_scope = @current_scope.parent #: as !nil
       end
 
       #: (Prism::BlockLocalVariableNode node) -> void
@@ -301,7 +307,8 @@ module RubyLsp
         # For each capture name we find in the regexp, look for a local in the current_scope
         Regexp.new(content, Regexp::FIXEDENCODING).names.each do |name|
           # The +3 is to compensate for the "(?<" part of the capture name
-          capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
+          capture_name_index = content.index("(?<#{name}>") #: as !nil
+          capture_name_offset = capture_name_index + 3
           local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
           local = @current_scope.lookup(name)

data/lib/ruby_lsp/listeners/signature_help.rb

@@ -69,7 +69,11 @@ module RubyLsp
           signature.matches?(arguments)
         end || 0
 
-        parameter_length = [T.must(signatures[active_sig_index]).parameters.length - 1, 0].max
+        parameter_length = [
+          signatures[active_sig_index] #: as !nil
+            .parameters.length - 1,
+          0,
+        ].max
         active_parameter = (arguments.length - 1).clamp(0, parameter_length)
 
         # If there are arguments, then we need to check if there's a trailing comma after the end of the last argument

data/lib/ruby_lsp/listeners/spec_style.rb

@@ -148,7 +148,7 @@ module RubyLsp
       def in_spec_context?
         return true if @nesting.empty?
 
-        T.must(@spec_class_stack.last)
+        @spec_class_stack.last #: as !nil
       end
     end
   end

data/lib/ruby_lsp/listeners/test_style.rb

@@ -22,7 +22,7 @@ module RubyLsp
           queue = items.dup
 
           until queue.empty?
-            item = T.must(queue.shift)
+            item = queue.shift #: as !nil
             tags = Set.new(item[:tags])
             next unless tags.include?("framework:minitest") || tags.include?("framework:test_unit")
 
@@ -93,9 +93,9 @@ module RubyLsp
             if examples.empty?
               "^#{group_regex}(#|::)"
             elsif examples.length == 1
-              "^#{group_regex}##{examples[0]}$"
+              "^#{group_regex}##{examples[0]}\\$"
             else
-              "^#{group_regex}#(#{examples.join("|")})$"
+              "^#{group_regex}#(#{examples.join("|")})\\$"
             end
           end
 
@@ -116,13 +116,13 @@ module RubyLsp
               Shellwords.escape(TestDiscovery::DYNAMIC_REFERENCE_MARKER),
               ".*",
             )
-            command = +"#{BASE_COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}$/\""
+            command = +"#{BASE_COMMAND} -Itest #{file_path} --testcase \"/^#{group_regex}\\$/\""
 
             unless examples.empty?
               command << if examples.length == 1
-                " --name \"/#{examples[0]}$/\""
+                " --name \"/#{examples[0]}\\$/\""
               else
-                " --name \"/(#{examples.join("|")})$/\""
+                " --name \"/(#{examples.join("|")})\\$/\""
               end
             end
 
@@ -133,8 +133,8 @@ module RubyLsp
 
       include Requests::Support::Common
 
-      MINITEST_REPORTER_PATH = File.expand_path("../ruby_lsp_reporter_plugin.rb", __dir__) #: String
-      TEST_UNIT_REPORTER_PATH = File.expand_path("../test_unit_test_runner.rb", __dir__) #: String
+      MINITEST_REPORTER_PATH = File.expand_path("../test_reporters/minitest_reporter.rb", __dir__) #: String
+      TEST_UNIT_REPORTER_PATH = File.expand_path("../test_reporters/test_unit_reporter.rb", __dir__) #: String
       ACCESS_MODIFIERS = [:public, :private, :protected].freeze
       BASE_COMMAND = begin
         Bundler.with_original_env { Bundler.default_lockfile }

data/lib/ruby_lsp/requests/code_action_resolve.rb

@@ -97,7 +97,7 @@ module RubyLsp
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest statements node, so that we place the refactor in a valid position
         node_context = RubyDocument
@@ -115,10 +115,10 @@ module RubyLsp
 
         # Find the node with the end line closest to the requested position, so that we can place the refactor
         # immediately after that closest node
-        closest_node = T.must(closest_statements.child_nodes.compact.min_by do |node|
+        closest_node = closest_statements.child_nodes.compact.min_by do |node|
           distance = source_range.dig(:start, :line) - (node.location.end_line - 1)
           distance <= 0 ? Float::INFINITY : distance
-        end)
+        end #: as !nil
 
         return Error::InvalidTargetRange if closest_node.is_a?(Prism::MissingNode)
 
@@ -153,7 +153,8 @@ module RubyLsp
           indentation_line = lines[indentation_line_number]
           return Error::InvalidTargetRange unless indentation_line
 
-          indentation = T.must(indentation_line[/\A */]).size
+          indentation = indentation_line[/\A */] #: as !nil
+            .size
 
           target_range = {
             start: { line: target_line, character: indentation },
@@ -195,7 +196,7 @@ module RubyLsp
         return Error::EmptySelection if source_range[:start] == source_range[:end]
 
         start_index, end_index = @document.find_index_by_position(source_range[:start], source_range[:end])
-        extracted_source = T.must(@document.source[start_index...end_index])
+        extracted_source = @document.source[start_index...end_index] #: as !nil
 
         # Find the closest method declaration node, so that we place the refactor in a valid position
         node_context = RubyDocument.locate(
@@ -379,16 +380,14 @@ module RubyLsp
 
         attribute_name = node.name[1..]
         indentation = " " * (closest_node.location.start_column + 2)
-        attribute_accessor_source = T.must(
-          case @code_action[:title]
-          when CodeActions::CREATE_ATTRIBUTE_READER
-            "#{indentation}attr_reader :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_WRITER
-            "#{indentation}attr_writer :#{attribute_name}\n\n"
-          when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
-            "#{indentation}attr_accessor :#{attribute_name}\n\n"
-          end,
-        )
+        attribute_accessor_source = case @code_action[:title]
+        when CodeActions::CREATE_ATTRIBUTE_READER
+          "#{indentation}attr_reader :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_WRITER
+          "#{indentation}attr_writer :#{attribute_name}\n\n"
+        when CodeActions::CREATE_ATTRIBUTE_ACCESSOR
+          "#{indentation}attr_accessor :#{attribute_name}\n\n"
+        end #: as !nil
 
         target_start_line = closest_node.location.start_line
         target_range = {

data/lib/ruby_lsp/requests/completion_resolve.rb

@@ -54,7 +54,7 @@ module RubyLsp
           end
         end
 
-        first_entry = T.must(entries.first)
+        first_entry = entries.first #: as !nil
 
         if first_entry.is_a?(RubyIndexer::Entry::Member)
           label = +"#{label}#{first_entry.decorated_parameters}"

data/lib/ruby_lsp/requests/hover.rb

@@ -37,8 +37,8 @@ module RubyLsp
 
         if should_refine_target?(parent, target)
           target = determine_target(
-            T.must(target),
-            T.must(parent),
+            target, #: as !nil
+            parent, #: as !nil
             position,
           )
         elsif position_outside_target?(position, target)

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -51,7 +51,9 @@ module RubyLsp
           # But if it's a RBS signature starting with `#:`, we'll ignore it
           # so users can immediately continue typing the method definition
           if (comment_match = @previous_line.match(/^#(?!:)(\s*)/))
-            handle_comment_line(T.must(comment_match[1]))
+            handle_comment_line(
+              comment_match[1], #: as !nil
+            )
           elsif @document.syntax_error?
             match = /(<<((-|~)?))(?<quote>['"`]?)(?<delimiter>\w+)\k<quote>/.match(@previous_line)
             heredoc_delimiter = match && match.named_captures["delimiter"]
@@ -76,7 +78,7 @@ module RubyLsp
         current_line = @lines[@position[:line]]
         return unless /((?<=do)|(?<={))\s+\|/.match?(current_line)
 
-        line = T.must(current_line)
+        line = current_line #: as !nil
 
         # If the user inserts the closing pipe manually to the end of the block argument, we need to avoid adding
         # an additional one and remove the previous one.  This also helps to remove the user who accidentally

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -49,8 +49,7 @@ module RubyLsp
 
         # While the spec allows for multiple entries, VSCode seems to only support one
         # We'll just return the first one for now
-        first_entry = T.must(entries.first)
-
+        first_entry = entries.first #: as !nil
         range = range_from_location(first_entry.location)
 
         [

data/lib/ruby_lsp/requests/references.rb

@@ -106,7 +106,8 @@ module RubyLsp
           entries = @global_state.index.resolve(name, node_context.nesting)
           return unless entries
 
-          fully_qualified_name = T.must(entries.first).name
+          fully_qualified_name = entries.first #: as !nil
+            .name
           RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
         when
           Prism::InstanceVariableAndWriteNode,

data/lib/ruby_lsp/requests/rename.rb

@@ -63,10 +63,11 @@ module RubyLsp
         return unless entries
 
         if (conflict_entries = @global_state.index.resolve(@new_name, node_context.nesting))
-          raise InvalidNameError, "The new name is already in use by #{T.must(conflict_entries.first).name}"
+          raise InvalidNameError, "The new name is already in use by #{conflict_entries.first&.name}"
         end
 
-        fully_qualified_name = T.must(entries.first).name
+        fully_qualified_name = entries.first #: as !nil
+          .name
         reference_target = RubyIndexer::ReferenceFinder::ConstTarget.new(fully_qualified_name)
         changes = collect_text_edits(reference_target, name)
 
@@ -97,9 +98,9 @@ module RubyLsp
         # rename the files for the user.
         #
         # We also look for an associated test file and rename it too
-        short_name = T.must(fully_qualified_name.split("::").last)
+        short_name = fully_qualified_name.split("::").last #: as !nil
 
-        T.must(@global_state.index[fully_qualified_name]).each do |entry|
+        @global_state.index[fully_qualified_name]&.each do |entry|
           # Do not rename files that are not part of the workspace
           uri = entry.uri
           file_path = uri.full_path
@@ -112,7 +113,9 @@ module RubyLsp
             file_name = file_from_constant_name(short_name)
 
             if "#{file_name}.rb" == entry.file_name
-              new_file_name = file_from_constant_name(T.must(@new_name.split("::").last))
+              new_file_name = file_from_constant_name(
+                @new_name.split("::").last, #: as !nil
+              )
 
               new_uri = URI::Generic.from_path(path: File.join(
                 File.dirname(file_path),

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -32,7 +32,7 @@ module RubyLsp
           next unless node
 
           range = Support::SelectionRange.new(range: range_from_location(node.location), parent: parent)
-          T.unsafe(queue).unshift(*node.child_nodes.map { |child| [child, range] })
+          queue.unshift(*node.child_nodes.map { |child| [child, range] })
           @ranges.unshift(range)
         end
 

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -43,8 +43,8 @@ module RubyLsp
           # Filter the tokens based on the first different position. This must happen at this stage, before we try to
           # find the next position from the end or else we risk confusing sets of token that may have different lengths,
           # but end with the exact same token
-          old_tokens = T.must(previous_tokens[first_different_position...])
-          new_tokens = T.must(current_tokens[first_different_position...])
+          old_tokens = previous_tokens[first_different_position...] #: as !nil
+          new_tokens = current_tokens[first_different_position...] #: as !nil
 
           # Then search from the end to find the first token that doesn't match. Since the user is normally editing the
           # middle of the file, this will minimize the number of edits since the end of the token array has not changed
@@ -53,8 +53,8 @@ module RubyLsp
           end || 0
 
           # Filter the old and new tokens to only the section that will be replaced/inserted/deleted
-          old_tokens = T.must(old_tokens[...old_tokens.length - first_different_token_from_end])
-          new_tokens = T.must(new_tokens[...new_tokens.length - first_different_token_from_end])
+          old_tokens = old_tokens[...old_tokens.length - first_different_token_from_end] #: as !nil
+          new_tokens = new_tokens[...new_tokens.length - first_different_token_from_end] #: as !nil
 
           # And we send back a single edit, replacing an entire section for the new tokens
           Interface::SemanticTokensDelta.new(

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -29,7 +29,7 @@ module RubyLsp
 
       #: -> String
       def ast_for_range
-        range = T.must(@range)
+        range = @range #: as !nil
         start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup
@@ -46,7 +46,7 @@ module RubyLsp
           if (start_char..end_char).cover?(loc.start_offset..loc.end_offset)
             found_nodes << node
           else
-            T.unsafe(queue).unshift(*node.child_nodes)
+            queue.unshift(*node.child_nodes)
           end
         end
 

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

@@ -54,7 +54,9 @@ module RubyLsp
         #: (String file_path) -> bool?
         def not_in_dependencies?(file_path)
           BUNDLE_PATH &&
-            !file_path.start_with?(T.must(BUNDLE_PATH)) &&
+            !file_path.start_with?(
+              BUNDLE_PATH, #: as !nil
+            ) &&
             !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
         end
 

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

@@ -21,7 +21,7 @@ module RubyLsp
         # @override
         #: (URI::Generic uri, RubyDocument document) -> String?
         def run_formatting(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
+          filename = uri.to_standardized_path || uri.opaque #: as !nil
 
           # Invoke RuboCop with just this file in `paths`
           @format_runner.run(filename, document.source)
@@ -38,7 +38,7 @@ module RubyLsp
         # @override
         #: (URI::Generic uri, RubyDocument document) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document)
-          filename = T.must(uri.to_standardized_path || uri.opaque)
+          filename = uri.to_standardized_path || uri.opaque #: as !nil
           # Invoke RuboCop with just this file in `paths`
           @diagnostic_runner.run(filename, document.source)
 

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

@@ -21,8 +21,10 @@ module URI
     # have the uri gem in their own bundle and thus not use a compatible version.
     PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
-    T.unsafe(self).alias_method(:gem_name, :host)
-    T.unsafe(self).alias_method(:line_number, :fragment)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:gem_name, :host)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:line_number, :fragment)
 
     #: String?
     attr_reader :gem_version
@@ -71,7 +73,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = @@schemes # rubocop:disable Style/ClassVars #: Hash[String, untyped]
+      @@schemes = @@schemes #: Hash[String, untyped] # rubocop:disable Style/ClassVars
       @@schemes["SOURCE"] = self
     end
   end

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -38,13 +38,14 @@ module RubyLsp
 
       #: -> (SymbolHierarchyRoot | Interface::DocumentSymbol)
       def last
-        T.must(@stack.last)
+        @stack.last #: as !nil
       end
 
       # @override
       #: -> Array[Interface::DocumentSymbol]
       def response
-        T.must(@stack.first).children
+        @stack.first #: as !nil
+          .children
       end
     end
   end

data/lib/ruby_lsp/response_builders/hover.rb

@@ -35,7 +35,7 @@ module RubyLsp
       # @override
       #: -> ResponseType
       def response
-        result = T.must(@response[:title])
+        result = @response[:title] #: as !nil
         result << "\n" << @response[:links] if @response[:links]
         result << "\n" << @response[:documentation] if @response[:documentation]
 

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -64,7 +64,7 @@ module RubyLsp
             start_line: location.start_line,
             start_code_unit_column: location.cached_start_code_units_column(@code_units_cache),
             length: length,
-            type: T.must(TOKEN_TYPES[type]),
+            type: TOKEN_TYPES[type], #: as !nil
             modifier: modifiers_indices,
           ),
         )

data/lib/ruby_lsp/ruby_document.rb

@@ -53,7 +53,7 @@ module RubyLsp
           # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
           # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
           # sibling
-          T.unsafe(queue).unshift(*candidate.child_nodes)
+          queue.unshift(*candidate.child_nodes)
 
           # Skip if the current node doesn't cover the desired position
           loc = candidate.location
@@ -195,7 +195,7 @@ module RubyLsp
         # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
         # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
         # sibling
-        T.unsafe(queue).unshift(*candidate.child_nodes)
+        queue.unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location

data/lib/ruby_lsp/scripts/compose_bundle.rb

@@ -13,8 +13,10 @@ def compose(raw_initialize)
   workspace_path ||= Dir.pwd
 
   env = RubyLsp::SetupBundler.new(workspace_path, launcher: true).setup!
-  File.write(
-    File.join(".ruby-lsp", "bundle_env"),
-    env.map { |k, v| "#{k}=#{v}" }.join("\n"),
-  )
+
+  File.open(File.join(".ruby-lsp", "bundle_env"), "w") do |f|
+    f.flock(File::LOCK_EX)
+    f.write(env.map { |k, v| "#{k}=#{v}" }.join("\n"))
+    f.flush
+  end
 end

data/lib/ruby_lsp/server.rb

@@ -223,7 +223,8 @@ module RubyLsp
       configured_features = options.dig(:initializationOptions, :enabledFeatures)
 
       configured_hints = options.dig(:initializationOptions, :featuresConfiguration, :inlayHint)
-      T.must(@store.features_configuration.dig(:inlayHint)).configuration.merge!(configured_hints) if configured_hints
+      @store.features_configuration.dig(:inlayHint) #: as !nil
+        .configuration.merge!(configured_hints) if configured_hints
 
       enabled_features = case configured_features
       when Array
@@ -294,6 +295,7 @@ module RubyLsp
             addon_detection: true,
             compose_bundle: true,
             go_to_relevant_file: true,
+            full_test_discovery: true,
           },
         ),
         serverInfo: {
@@ -488,7 +490,11 @@ module RubyLsp
       document_symbol = Requests::DocumentSymbol.new(uri, dispatcher)
       document_link = Requests::DocumentLink.new(uri, parse_result.comments, dispatcher)
       code_lens = Requests::CodeLens.new(@global_state, uri, dispatcher)
-      inlay_hint = Requests::InlayHints.new(document, T.must(@store.features_configuration.dig(:inlayHint)), dispatcher)
+      inlay_hint = Requests::InlayHints.new(
+        document,
+        @store.features_configuration.dig(:inlayHint), #: as !nil
+        dispatcher,
+      )
 
       if document.is_a?(RubyDocument) && document.should_index?
         # Re-index the file as it is modified. This mode of indexing updates entries only. Require path trees are only
@@ -815,7 +821,7 @@ module RubyLsp
         return
       end
 
-      hints_configurations = T.must(@store.features_configuration.dig(:inlayHint))
+      hints_configurations = @store.features_configuration.dig(:inlayHint) #: as !nil
       dispatcher = Prism::Dispatcher.new
 
       unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
@@ -1056,7 +1062,8 @@ module RubyLsp
       end
 
       Addon.file_watcher_addons.each do |addon|
-        T.unsafe(addon).workspace_did_change_watched_files(changes)
+        addon #: as untyped
+          .workspace_did_change_watched_files(changes)
       rescue => e
         send_log_message(
           "Error in #{addon.name} add-on while processing watched file notifications: #{e.full_message}",
@@ -1393,7 +1400,9 @@ module RubyLsp
           Open3.capture3(
             Gem.ruby,
             "-I",
-            File.dirname(T.must(__dir__)),
+            File.dirname(
+              __dir__, #: as !nil
+            ),
             File.expand_path("../../exe/ruby-lsp-launcher", __dir__),
             @global_state.workspace_uri.to_s,
             chdir: @global_state.workspace_path,

data/lib/ruby_lsp/setup_bundler.rb

@@ -260,7 +260,8 @@ module RubyLsp
       # The ENV can only be merged after checking if an update is required because we depend on the original value of
       # ENV["BUNDLE_GEMFILE"], which gets overridden after the merge
       should_update = should_bundle_update?
-      T.unsafe(ENV).merge!(env)
+      ENV #: as untyped
+        .merge!(env)
 
       unless should_update && !force_install
         Bundler::CLI::Install.new({ "no-cache" => true }).run
@@ -405,12 +406,15 @@ module RubyLsp
     def correct_relative_remote_paths
       content = @custom_lockfile.read
       content.gsub!(/remote: (.*)/) do |match|
-        path = T.must(Regexp.last_match)[1]
+        last_match = Regexp.last_match #: as !nil
+        path = last_match[1]
 
         # We should only apply the correction if the remote is a relative path. It might also be a URI, like
         # `https://rubygems.org` or an absolute path, in which case we shouldn't do anything
         if path && !URI(path).scheme
-          "remote: #{File.expand_path(path, T.must(@gemfile).dirname)}"
+          bundle_dir = @gemfile #: as !nil
+            .dirname
+          "remote: #{File.expand_path(path, bundle_dir)}"
         else
           match
         end

data/lib/ruby_lsp/static_docs.rb

@@ -3,7 +3,14 @@
 
 module RubyLsp
   # The path to the `static_docs` directory, where we keep long-form static documentation
-  STATIC_DOCS_PATH = File.join(File.dirname(File.dirname(T.must(__dir__))), "static_docs") #: String
+  STATIC_DOCS_PATH = File.join(
+    File.dirname(
+      File.dirname(
+        __dir__, #: as !nil
+      ),
+    ),
+    "static_docs",
+  ) #: String
 
   # A map of keyword => short documentation to be displayed on hover or completion
   KEYWORD_DOCS = {

data/lib/ruby_lsp/store.rb

@@ -46,7 +46,7 @@ module RubyLsp
       end
 
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
-      T.must(@state[uri.to_s])
+      @state[uri.to_s] #: as !nil
     rescue Errno::ENOENT
       raise NonExistingDocumentError, uri.to_s
     end
@@ -65,7 +65,8 @@ module RubyLsp
 
     #: (uri: URI::Generic, edits: Array[Hash[Symbol, untyped]], version: Integer) -> void
     def push_edits(uri:, edits:, version:)
-      T.must(@state[uri.to_s]).push_edits(edits, version: version)
+      @state[uri.to_s] #: as !nil
+        .push_edits(edits, version: version)
     end
 
     #: -> void