ruby-lsp 0.23.11 → 0.26.1

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
 

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -11,28 +11,28 @@ module RubyLsp
     #
     # Note that if using VSCode Neovim, you will need to be in Insert mode for this to work correctly.
     class SelectionRanges < Request
-      extend T::Sig
       include Support::Common
 
-      sig { params(document: T.any(RubyDocument, ERBDocument)).void }
+      #: ((RubyDocument | ERBDocument) document) -> void
       def initialize(document)
         super()
         @document = document
-        @ranges = T.let([], T::Array[Support::SelectionRange])
-        @stack = T.let([], T::Array[Support::SelectionRange])
+        @ranges = [] #: Array[Support::SelectionRange]
+        @stack = [] #: Array[Support::SelectionRange]
       end
 
-      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
+      # @override
+      #: -> (Array[Support::SelectionRange] & Object)
       def perform
         # [node, parent]
-        queue = [[@document.parse_result.value, nil]]
+        queue = [[@document.ast, nil]]
 
         until queue.empty?
           node, parent = queue.shift
           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

@@ -9,12 +9,8 @@ module RubyLsp
     # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)
     # request informs the editor of the correct token types to provide consistent and accurate highlighting for themes.
     class SemanticHighlighting < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::SemanticTokensRegistrationOptions) }
+        #: -> Interface::SemanticTokensRegistrationOptions
         def provider
           Interface::SemanticTokensRegistrationOptions.new(
             document_selector: nil,
@@ -29,13 +25,7 @@ module RubyLsp
 
         # The compute_delta method receives the current semantic tokens and the previous semantic tokens and then tries
         # to compute the smallest possible semantic token edit that will turn previous into current
-        sig do
-          params(
-            current_tokens: T::Array[Integer],
-            previous_tokens: T::Array[Integer],
-            result_id: String,
-          ).returns(Interface::SemanticTokensDelta)
-        end
+        #: (Array[Integer] current_tokens, Array[Integer] previous_tokens, String result_id) -> Interface::SemanticTokensDelta
         def compute_delta(current_tokens, previous_tokens, result_id)
           # Find the index of the first token that is different between the two sets of tokens
           first_different_position = current_tokens.zip(previous_tokens).find_index { |new, old| new != old }
@@ -53,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
@@ -63,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(
@@ -73,7 +63,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(Integer) }
+        #: -> Integer
         def next_result_id
           @mutex.synchronize do
             @result_id += 1
@@ -81,29 +71,19 @@ module RubyLsp
         end
       end
 
-      @result_id = T.let(0, Integer)
-      @mutex = T.let(Mutex.new, Mutex)
-
-      sig do
-        params(
-          global_state: GlobalState,
-          dispatcher: Prism::Dispatcher,
-          document: T.any(RubyDocument, ERBDocument),
-          previous_result_id: T.nilable(String),
-          range: T.nilable(T::Range[Integer]),
-        ).void
-      end
+      @result_id = 0 #: Integer
+      @mutex = Mutex.new #: Mutex
+
+      #: (GlobalState global_state, Prism::Dispatcher dispatcher, (RubyDocument | ERBDocument) document, String? previous_result_id, ?range: Range[Integer]?) -> void
       def initialize(global_state, dispatcher, document, previous_result_id, range: nil)
         super()
 
         @document = document
         @previous_result_id = previous_result_id
         @range = range
-        @result_id = T.let(SemanticHighlighting.next_result_id.to_s, String)
-        @response_builder = T.let(
-          ResponseBuilders::SemanticHighlighting.new(document.code_units_cache),
-          ResponseBuilders::SemanticHighlighting,
-        )
+        @result_id = SemanticHighlighting.next_result_id.to_s #: String
+        @response_builder = ResponseBuilders::SemanticHighlighting
+          .new(document.code_units_cache) #: ResponseBuilders::SemanticHighlighting
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder)
 
         Addon.addons.each do |addon|
@@ -111,7 +91,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T.any(Interface::SemanticTokens, Interface::SemanticTokensDelta)) }
+      # @override
+      #: -> (Interface::SemanticTokens | Interface::SemanticTokensDelta)
       def perform
         previous_tokens = @document.semantic_tokens
         tokens = @response_builder.response