ruby-lsp 0.23.11 → 0.26.4

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -6,12 +6,8 @@ module RubyLsp
     # The [on type formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_onTypeFormatting)
     # request formats code as the user is typing. For example, automatically adding `end` to class definitions.
     class OnTypeFormatting < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentOnTypeFormattingRegistrationOptions) }
+        #: -> Interface::DocumentOnTypeFormattingRegistrationOptions
         def provider
           Interface::DocumentOnTypeFormattingRegistrationOptions.new(
             document_selector: nil,
@@ -21,38 +17,29 @@ module RubyLsp
         end
       end
 
-      END_REGEXES = T.let(
-        [
-          /\b(if|unless|for|while|until)\b($|\s|\()/,
-          /\b(class|module|def|case)\b($|\s)/,
-          /.*\s\bdo\b($|\s)/,
-        ],
-        T::Array[Regexp],
-      )
-
-      sig do
-        params(
-          document: RubyDocument,
-          position: T::Hash[Symbol, T.untyped],
-          trigger_character: String,
-          client_name: String,
-        ).void
-      end
+      END_REGEXES = [
+        /\b(if|unless|for|while|until)\b($|\s|\()/,
+        /\b(class|module|def|case)\b($|\s)/,
+        /.*\s\bdo\b($|\s)/,
+      ] #: Array[Regexp]
+
+      #: (RubyDocument document, Hash[Symbol, untyped] position, String trigger_character, String client_name) -> void
       def initialize(document, position, trigger_character, client_name)
         super()
         @document = document
-        @lines = T.let(@document.source.lines, T::Array[String])
+        @lines = @document.source.lines #: Array[String]
         line = @lines[[position[:line] - 1, 0].max]
 
-        @indentation = T.let(line ? find_indentation(line) : 0, Integer)
-        @previous_line = T.let(line ? line.strip.chomp : "", String)
+        @indentation = line ? find_indentation(line) : 0 #: Integer
+        @previous_line = line ? line.strip.chomp : "" #: String
         @position = position
-        @edits = T.let([], T::Array[Interface::TextEdit])
+        @edits = [] #: Array[Interface::TextEdit]
         @trigger_character = trigger_character
         @client_name = client_name
       end
 
-      sig { override.returns(T.all(T::Array[Interface::TextEdit], Object)) }
+      # @override
+      #: -> (Array[Interface::TextEdit] & Object)
       def perform
         case @trigger_character
         when "{"
@@ -60,8 +47,13 @@ module RubyLsp
         when "|"
           handle_pipe if @document.syntax_error?
         when "\n"
-          if (comment_match = @previous_line.match(/^#(\s*)/))
-            handle_comment_line(T.must(comment_match[1]))
+          # If the previous line is a simple comment, we'll add a comment continuation
+          # 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(
+              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"]
@@ -81,12 +73,12 @@ module RubyLsp
 
       private
 
-      sig { void }
+      #: -> void
       def handle_pipe
         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
@@ -112,7 +104,7 @@ module RubyLsp
         move_cursor_to(@position[:line], @position[:character])
       end
 
-      sig { void }
+      #: -> void
       def handle_curly_brace
         return unless /".*#\{/.match?(@previous_line)
 
@@ -120,7 +112,7 @@ module RubyLsp
         move_cursor_to(@position[:line], @position[:character])
       end
 
-      sig { void }
+      #: -> void
       def handle_statement_end
         # If a keyword occurs in a line which appears be a comment or a string, we will not try to format it, since
         # it could be a coincidental match. This approach is not perfect, but it should cover most cases.
@@ -142,7 +134,7 @@ module RubyLsp
         end
       end
 
-      sig { params(delimiter: String).void }
+      #: (String delimiter) -> void
       def handle_heredoc_end(delimiter)
         indents = " " * @indentation
         add_edit_with_text("\n")
@@ -150,12 +142,12 @@ module RubyLsp
         move_cursor_to(@position[:line], @indentation + 2)
       end
 
-      sig { params(spaces: String).void }
+      #: (String spaces) -> void
       def handle_comment_line(spaces)
         add_edit_with_text("##{spaces}")
       end
 
-      sig { params(text: String, position: T::Hash[Symbol, T.untyped]).void }
+      #: (String text, ?Hash[Symbol, untyped] position) -> void
       def add_edit_with_text(text, position = @position)
         pos = Interface::Position.new(
           line: position[:line],
@@ -168,9 +160,9 @@ module RubyLsp
         )
       end
 
-      sig { params(line: Integer, character: Integer).void }
+      #: (Integer line, Integer character) -> void
       def move_cursor_to(line, character)
-        return unless /Visual Studio Code|Cursor/.match?(@client_name)
+        return unless /Visual Studio Code|Cursor|VSCodium|Windsurf/.match?(@client_name)
 
         position = Interface::Position.new(
           line: line,
@@ -189,7 +181,7 @@ module RubyLsp
         )
       end
 
-      sig { params(line: String).returns(Integer) }
+      #: (String line) -> Integer
       def find_indentation(line)
         count = 0
 
@@ -202,7 +194,7 @@ module RubyLsp
         count
       end
 
-      sig { void }
+      #: -> void
       def auto_indent_after_end_keyword
         current_line = @lines[@position[:line]]
         return unless current_line && current_line.strip == "end"

data/lib/ruby_lsp/requests/prepare_rename.rb

@@ -7,27 +7,22 @@ module RubyLsp
     # [prepare_rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_prepareRename)
     # # request checks the validity of a rename operation at a given location.
     class PrepareRename < Request
-      extend T::Sig
       include Support::Common
 
-      sig do
-        params(
-          document: RubyDocument,
-          position: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: (RubyDocument document, Hash[Symbol, untyped] position) -> void
       def initialize(document, position)
         super()
         @document = document
-        @position = T.let(position, T::Hash[Symbol, Integer])
+        @position = position #: Hash[Symbol, Integer]
       end
 
-      sig { override.returns(T.nilable(Interface::Range)) }
+      # @override
+      #: -> Interface::Range?
       def perform
         char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
-          @document.parse_result.value,
+          @document.ast,
           char_position,
           node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
           code_units_cache: @document.code_units_cache,

data/lib/ruby_lsp/requests/prepare_type_hierarchy.rb

@@ -9,26 +9,16 @@ module RubyLsp
     #
     # Currently only supports supertypes due to a limitation of the index.
     class PrepareTypeHierarchy < Request
-      extend T::Sig
-
       include Support::Common
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::TypeHierarchyOptions) }
+        #: -> Interface::TypeHierarchyOptions
         def provider
           Interface::TypeHierarchyOptions.new
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          index: RubyIndexer::Index,
-          position: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, RubyIndexer::Index index, Hash[Symbol, untyped] position) -> void
       def initialize(document, index, position)
         super()
 
@@ -37,7 +27,8 @@ module RubyLsp
         @position = position
       end
 
-      sig { override.returns(T.nilable(T::Array[Interface::TypeHierarchyItem])) }
+      # @override
+      #: -> Array[Interface::TypeHierarchyItem]?
       def perform
         context = @document.locate_node(
           @position,
@@ -58,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/range_formatting.rb

@@ -6,18 +6,17 @@ module RubyLsp
     # The [range formatting](https://microsoft.github.io/language-server-protocol/specification#textDocument_rangeFormatting)
     # is used to format a selection or to format on paste.
     class RangeFormatting < Request
-      extend T::Sig
-
-      sig { params(global_state: GlobalState, document: RubyDocument, params: T::Hash[Symbol, T.untyped]).void }
+      #: (GlobalState global_state, RubyDocument document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, document, params)
         super()
         @document = document
-        @uri = T.let(document.uri, URI::Generic)
+        @uri = document.uri #: URI::Generic
         @params = params
-        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
+        @active_formatter = global_state.active_formatter #: Support::Formatter?
       end
 
-      sig { override.returns(T.nilable(T::Array[Interface::TextEdit])) }
+      # @override
+      #: -> Array[Interface::TextEdit]?
       def perform
         return unless @active_formatter
         return if @document.syntax_error?

data/lib/ruby_lsp/requests/references.rb

@@ -7,33 +7,26 @@ module RubyLsp
     # [references](https://microsoft.github.io/language-server-protocol/specification#textDocument_references)
     # request finds all references for the selected symbol.
     class References < Request
-      extend T::Sig
       include Support::Common
 
-      sig do
-        params(
-          global_state: GlobalState,
-          store: Store,
-          document: T.any(RubyDocument, ERBDocument),
-          params: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: (GlobalState global_state, Store store, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
         @store = store
         @document = document
         @params = params
-        @locations = T.let([], T::Array[Interface::Location])
+        @locations = [] #: Array[Interface::Location]
       end
 
-      sig { override.returns(T::Array[Interface::Location]) }
+      # @override
+      #: -> Array[Interface::Location]
       def perform
         position = @params[:position]
         char_position, _ = @document.find_index_by_position(position)
 
         node_context = RubyDocument.locate(
-          @document.parse_result.value,
+          @document.ast,
           char_position,
           node_types: [
             Prism::ConstantReadNode,
@@ -62,22 +55,7 @@ module RubyLsp
           )
         end
 
-        target = T.cast(
-          target,
-          T.any(
-            Prism::ConstantReadNode,
-            Prism::ConstantPathNode,
-            Prism::ConstantPathTargetNode,
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-            Prism::CallNode,
-            Prism::DefNode,
-          ),
-        )
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode,
 
         reference_target = create_reference_target(target, node_context)
         return @locations unless reference_target
@@ -88,7 +66,7 @@ module RubyLsp
           # of reading from disk
           next if @store.key?(uri)
 
-          parse_result = Prism.parse_file(path)
+          parse_result = Prism.parse_lex_file(path)
           collect_references(reference_target, parse_result, uri)
         rescue Errno::EISDIR, Errno::ENOENT
           # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
@@ -103,24 +81,7 @@ module RubyLsp
 
       private
 
-      sig do
-        params(
-          target_node: T.any(
-            Prism::ConstantReadNode,
-            Prism::ConstantPathNode,
-            Prism::ConstantPathTargetNode,
-            Prism::InstanceVariableAndWriteNode,
-            Prism::InstanceVariableOperatorWriteNode,
-            Prism::InstanceVariableOrWriteNode,
-            Prism::InstanceVariableReadNode,
-            Prism::InstanceVariableTargetNode,
-            Prism::InstanceVariableWriteNode,
-            Prism::CallNode,
-            Prism::DefNode,
-          ),
-          node_context: NodeContext,
-        ).returns(T.nilable(RubyIndexer::ReferenceFinder::Target))
-      end
+      #: ((Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode | Prism::InstanceVariableAndWriteNode | Prism::InstanceVariableOperatorWriteNode | Prism::InstanceVariableOrWriteNode | Prism::InstanceVariableReadNode | Prism::InstanceVariableTargetNode | Prism::InstanceVariableWriteNode | Prism::CallNode | Prism::DefNode) target_node, NodeContext node_context) -> RubyIndexer::ReferenceFinder::Target?
       def create_reference_target(target_node, node_context)
         case target_node
         when Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode
@@ -130,7 +91,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,
@@ -139,19 +101,17 @@ module RubyLsp
           Prism::InstanceVariableReadNode,
           Prism::InstanceVariableTargetNode,
           Prism::InstanceVariableWriteNode
-          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s)
+          receiver_type = @global_state.type_inferrer.infer_receiver_type(node_context)
+          return unless receiver_type
+
+          ancestors = @global_state.index.linearized_ancestors_of(receiver_type.name)
+          RubyIndexer::ReferenceFinder::InstanceVariableTarget.new(target_node.name.to_s, ancestors)
         when Prism::CallNode, Prism::DefNode
           RubyIndexer::ReferenceFinder::MethodTarget.new(target_node.name.to_s)
         end
       end
 
-      sig do
-        params(
-          target: RubyIndexer::ReferenceFinder::Target,
-          parse_result: Prism::ParseResult,
-          uri: URI::Generic,
-        ).void
-      end
+      #: (RubyIndexer::ReferenceFinder::Target target, Prism::LexResult parse_result, URI::Generic uri) -> void
       def collect_references(target, parse_result, uri)
         dispatcher = Prism::Dispatcher.new
         finder = RubyIndexer::ReferenceFinder.new(
@@ -161,7 +121,7 @@ module RubyLsp
           uri,
           include_declarations: @params.dig(:context, :includeDeclaration) || true,
         )
-        dispatcher.visit(parse_result.value)
+        dispatcher.visit(parse_result.value.first)
 
         finder.references.each do |reference|
           @locations << Interface::Location.new(

data/lib/ruby_lsp/requests/rename.rb

@@ -7,43 +7,34 @@ module RubyLsp
     # [rename](https://microsoft.github.io/language-server-protocol/specification#textDocument_rename)
     # request renames all instances of a symbol in a document.
     class Rename < Request
-      extend T::Sig
       include Support::Common
 
       class InvalidNameError < StandardError; end
 
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::RenameOptions) }
+        #: -> Interface::RenameOptions
         def provider
           Interface::RenameOptions.new(prepare_provider: true)
         end
       end
 
-      sig do
-        params(
-          global_state: GlobalState,
-          store: Store,
-          document: T.any(RubyDocument, ERBDocument),
-          params: T::Hash[Symbol, T.untyped],
-        ).void
-      end
+      #: (GlobalState global_state, Store store, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] params) -> void
       def initialize(global_state, store, document, params)
         super()
         @global_state = global_state
         @store = store
         @document = document
-        @position = T.let(params[:position], T::Hash[Symbol, Integer])
-        @new_name = T.let(params[:newName], String)
+        @position = params[:position] #: Hash[Symbol, Integer]
+        @new_name = params[:newName] #: String
       end
 
-      sig { override.returns(T.nilable(Interface::WorkspaceEdit)) }
+      # @override
+      #: -> Interface::WorkspaceEdit?
       def perform
         char_position, _ = @document.find_index_by_position(@position)
 
         node_context = RubyDocument.locate(
-          @document.parse_result.value,
+          @document.ast,
           char_position,
           node_types: [Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode],
           code_units_cache: @document.code_units_cache,
@@ -60,10 +51,7 @@ module RubyLsp
           )
         end
 
-        target = T.cast(
-          target,
-          T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::ConstantPathTargetNode),
-        )
+        target = target #: as Prism::ConstantReadNode | Prism::ConstantPathNode | Prism::ConstantPathTargetNode
 
         name = RubyIndexer::Index.constant_name(target)
         return unless name
@@ -72,10 +60,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)
 
@@ -100,20 +89,15 @@ module RubyLsp
 
       private
 
-      sig do
-        params(
-          fully_qualified_name: String,
-          document_changes: T::Array[T.any(Interface::RenameFile, Interface::TextDocumentEdit)],
-        ).void
-      end
+      #: (String fully_qualified_name, Array[(Interface::RenameFile | Interface::TextDocumentEdit)] document_changes) -> void
       def collect_file_renames(fully_qualified_name, document_changes)
         # Check if the declarations of the symbol being renamed match the file name. In case they do, we automatically
         # 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
@@ -126,7 +110,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),
@@ -139,12 +125,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          target: RubyIndexer::ReferenceFinder::Target,
-          name: String,
-        ).returns(T::Hash[String, T::Array[Interface::TextEdit]])
-      end
+      #: (RubyIndexer::ReferenceFinder::Target target, String name) -> Hash[String, Array[Interface::TextEdit]]
       def collect_text_edits(target, name)
         changes = {}
 
@@ -155,39 +136,34 @@ module RubyLsp
           next if @store.key?(uri)
 
           parse_result = Prism.parse_file(path)
-          edits = collect_changes(target, parse_result, name, uri)
+          edits = collect_changes(target, parse_result.value, name, uri)
           changes[uri.to_s] = edits unless edits.empty?
         rescue Errno::EISDIR, Errno::ENOENT
           # If `path` is a directory, just ignore it and continue. If the file doesn't exist, then we also ignore it.
         end
 
         @store.each do |uri, document|
-          edits = collect_changes(target, document.parse_result, name, document.uri)
+          next unless document.is_a?(RubyDocument) || document.is_a?(ERBDocument)
+
+          edits = collect_changes(target, document.ast, name, document.uri)
           changes[uri] = edits unless edits.empty?
         end
 
         changes
       end
 
-      sig do
-        params(
-          target: RubyIndexer::ReferenceFinder::Target,
-          parse_result: Prism::ParseResult,
-          name: String,
-          uri: URI::Generic,
-        ).returns(T::Array[Interface::TextEdit])
-      end
-      def collect_changes(target, parse_result, name, uri)
+      #: (RubyIndexer::ReferenceFinder::Target target, Prism::Node ast, String name, URI::Generic uri) -> Array[Interface::TextEdit]
+      def collect_changes(target, ast, name, uri)
         dispatcher = Prism::Dispatcher.new
         finder = RubyIndexer::ReferenceFinder.new(target, @global_state.index, dispatcher, uri)
-        dispatcher.visit(parse_result.value)
+        dispatcher.visit(ast)
 
         finder.references.map do |reference|
           adjust_reference_for_edit(name, reference)
         end
       end
 
-      sig { params(name: String, reference: RubyIndexer::ReferenceFinder::Reference).returns(Interface::TextEdit) }
+      #: (String name, RubyIndexer::ReferenceFinder::Reference reference) -> Interface::TextEdit
       def adjust_reference_for_edit(name, reference)
         # The reference may include a namespace in front. We need to check if the rename new name includes namespaces
         # and then adjust both the text and the location to produce the correct edit
@@ -197,7 +173,7 @@ module RubyLsp
         Interface::TextEdit.new(range: range_from_location(location), new_text: new_text)
       end
 
-      sig { params(constant_name: String).returns(String) }
+      #: (String constant_name) -> String
       def file_from_constant_name(constant_name)
         constant_name
           .gsub(/([a-z])([A-Z])|([A-Z])([A-Z][a-z])/, '\1\3_\2\4')

data/lib/ruby_lsp/requests/request.rb

@@ -3,28 +3,21 @@
 
 module RubyLsp
   module Requests
+    # @abstract
     class Request
-      extend T::Sig
-      extend T::Generic
-
       class InvalidFormatter < StandardError; end
 
-      abstract!
-
-      sig { abstract.returns(T.anything) }
-      def perform; end
+      # @abstract
+      #: -> untyped
+      def perform
+        raise AbstractMethodInvokedError
+      end
 
       private
 
       # Signals to the client that the request should be delegated to the language server server for the host language
       # in ERB files
-      sig do
-        params(
-          global_state: GlobalState,
-          document: Document[T.untyped],
-          char_position: Integer,
-        ).void
-      end
+      #: (GlobalState global_state, Document[untyped] document, Integer char_position) -> void
       def delegate_request_if_needed!(global_state, document, char_position)
         if global_state.client_capabilities.supports_request_delegation &&
             document.is_a?(ERBDocument) &&
@@ -34,7 +27,7 @@ module RubyLsp
       end
 
       # Checks if a location covers a position
-      sig { params(location: Prism::Location, position: T.untyped).returns(T::Boolean) }
+      #: (Prism::Location location, untyped position) -> bool
       def cover?(location, position)
         start_covered =
           location.start_line - 1 < position[:line] ||
@@ -61,18 +54,13 @@ module RubyLsp
       #  #   ^ Going to definition here should go to Foo::Bar
       # #^ Going to definition here should go to Foo
       # ```
-      sig do
-        params(
-          target: Prism::Node,
-          parent: Prism::Node,
-          position: T::Hash[Symbol, Integer],
-        ).returns(Prism::Node)
-      end
+      #: (Prism::Node target, Prism::Node parent, Hash[Symbol, Integer] position) -> Prism::Node
       def determine_target(target, parent, position)
         return target unless parent.is_a?(Prism::ConstantPathNode)
 
-        target = T.let(parent, Prism::Node)
-        parent = T.let(T.cast(target, Prism::ConstantPathNode).parent, T.nilable(Prism::Node))
+        target = parent #: Prism::Node
+        parent = target #: as Prism::ConstantPathNode
+          .parent #: Prism::Node?
 
         while parent && cover?(parent.location, position)
           target = parent
@@ -83,7 +71,7 @@ module RubyLsp
       end
 
       # Checks if a given location covers the position requested
-      sig { params(location: T.nilable(Prism::Location), position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      #: (Prism::Location? location, Hash[Symbol, untyped] position) -> bool
       def covers_position?(location, position)
         return false unless location