ruby-lsp 0.23.11 → 0.26.1

data/lib/ruby_lsp/requests/discover_tests.rb

@@ -1,27 +1,29 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "ruby_lsp/listeners/test_discovery"
 require "ruby_lsp/listeners/test_style"
+require "ruby_lsp/listeners/spec_style"
 
 module RubyLsp
   module Requests
     # This is a custom request to ask the server to parse a test file and discover all available examples in it. Add-ons
     # can augment the behavior through listeners, allowing them to handle discovery for different frameworks
     class DiscoverTests < Request
-      extend T::Sig
       include Support::Common
 
-      sig { params(global_state: GlobalState, document: RubyDocument, dispatcher: Prism::Dispatcher).void }
+      #: (GlobalState global_state, RubyDocument document, Prism::Dispatcher dispatcher) -> void
       def initialize(global_state, document, dispatcher)
         super()
         @global_state = global_state
         @document = document
         @dispatcher = dispatcher
-        @response_builder = T.let(ResponseBuilders::TestCollection.new, ResponseBuilders::TestCollection)
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @response_builder = ResponseBuilders::TestCollection.new #: ResponseBuilders::TestCollection
+        @index = global_state.index #: RubyIndexer::Index
       end
 
-      sig { override.returns(T::Array[Support::TestItem]) }
+      # @override
+      #: -> Array[Support::TestItem]
       def perform
         uri = @document.uri
 
@@ -35,7 +37,13 @@ module RubyLsp
         # in the index first and then discover the tests, all in the same traversal.
         if @index.entries_for(uri.to_s)
           Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
-          @dispatcher.visit(@document.parse_result.value)
+          Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+          Addon.addons.each do |addon|
+            addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
+          end
+
+          @dispatcher.visit(@document.ast)
         else
           @global_state.synchronize do
             RubyIndexer::DeclarationListener.new(
@@ -47,11 +55,16 @@ module RubyLsp
             )
 
             Listeners::TestStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+            Listeners::SpecStyle.new(@response_builder, @global_state, @dispatcher, @document.uri)
+
+            Addon.addons.each do |addon|
+              addon.create_discover_tests_listener(@response_builder, @dispatcher, @document.uri)
+            end
 
             # Dispatch the events both for indexing the test file and discovering the tests. The order here is
             # important because we need the index to be aware of the existing classes/modules/methods before the test
             # listeners can do their work
-            @dispatcher.visit(@document.parse_result.value)
+            @dispatcher.visit(@document.ast)
           end
         end
 

data/lib/ruby_lsp/requests/document_highlight.rb

@@ -13,31 +13,20 @@ module RubyLsp
     # For writable elements like constants or variables, their read/write occurrences should be highlighted differently.
     # This is achieved by sending different "kind" attributes to the editor (2 for read and 3 for write).
     class DocumentHighlight < Request
-      extend T::Sig
-
-      sig do
-        params(
-          global_state: GlobalState,
-          document: T.any(RubyDocument, ERBDocument),
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (GlobalState global_state, (RubyDocument | ERBDocument) document, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher) -> void
       def initialize(global_state, document, position, dispatcher)
         super()
         char_position, _ = document.find_index_by_position(position)
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           code_units_cache: document.code_units_cache,
         )
 
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentHighlight]
         Listeners::DocumentHighlight.new(
           @response_builder,
           node_context.node,
@@ -47,7 +36,8 @@ module RubyLsp
         )
       end
 
-      sig { override.returns(T::Array[Interface::DocumentHighlight]) }
+      # @override
+      #: -> Array[Interface::DocumentHighlight]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/document_link.rb

@@ -9,34 +9,23 @@ module RubyLsp
     # makes `# source://PATH_TO_FILE#line` comments in a Ruby/RBI file clickable if the file exists.
     # When the user clicks the link, it'll open that location.
     class DocumentLink < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentLinkOptions) }
+        #: -> Interface::DocumentLinkOptions
         def provider
           Interface::DocumentLinkOptions.new(resolve_provider: false)
         end
       end
 
-      sig do
-        params(
-          uri: URI::Generic,
-          comments: T::Array[Prism::Comment],
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
+      #: (URI::Generic uri, Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, comments, dispatcher)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink],
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::DocumentLink]
         Listeners::DocumentLink.new(@response_builder, uri, comments, dispatcher)
       end
 
-      sig { override.returns(T::Array[Interface::DocumentLink]) }
+      # @override
+      #: -> Array[Interface::DocumentLink]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/document_symbol.rb

@@ -13,21 +13,17 @@ module RubyLsp
     # In VS Code, symbol search known as 'Go To Symbol in Editor' and can be accessed with Ctrl/Cmd-Shift-O,
     # or by opening the command palette and inserting an `@` symbol.
     class DocumentSymbol < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::DocumentSymbolOptions) }
+        #: -> Interface::DocumentSymbolOptions
         def provider
           Interface::DocumentSymbolOptions.new
         end
       end
 
-      sig { params(uri: URI::Generic, dispatcher: Prism::Dispatcher).void }
+      #: (URI::Generic uri, Prism::Dispatcher dispatcher) -> void
       def initialize(uri, dispatcher)
         super()
-        @response_builder = T.let(ResponseBuilders::DocumentSymbol.new, ResponseBuilders::DocumentSymbol)
+        @response_builder = ResponseBuilders::DocumentSymbol.new #: ResponseBuilders::DocumentSymbol
         Listeners::DocumentSymbol.new(@response_builder, uri, dispatcher)
 
         Addon.addons.each do |addon|
@@ -35,7 +31,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      # @override
+      #: -> Array[Interface::DocumentSymbol]
       def perform
         @response_builder.response
       end

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -8,31 +8,23 @@ module RubyLsp
     # The [folding ranges](https://microsoft.github.io/language-server-protocol/specification#textDocument_foldingRange)
     # request informs the editor of the ranges where and how code can be folded.
     class FoldingRanges < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(TrueClass) }
+        #: -> TrueClass
         def provider
           true
         end
       end
 
-      sig { params(comments: T::Array[Prism::Comment], dispatcher: Prism::Dispatcher).void }
+      #: (Array[Prism::Comment] comments, Prism::Dispatcher dispatcher) -> void
       def initialize(comments, dispatcher)
         super()
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange],
-        )
-        @listener = T.let(
-          Listeners::FoldingRanges.new(@response_builder, comments, dispatcher),
-          Listeners::FoldingRanges,
-        )
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::FoldingRange]
+        @listener = Listeners::FoldingRanges.new(@response_builder, comments, dispatcher) #: Listeners::FoldingRanges
       end
 
-      sig { override.returns(T::Array[Interface::FoldingRange]) }
+      # @override
+      #: -> Array[Interface::FoldingRange]
       def perform
         @listener.finalize_response!
         @response_builder.response

data/lib/ruby_lsp/requests/formatting.rb

@@ -7,28 +7,25 @@ module RubyLsp
     # request uses RuboCop to fix auto-correctable offenses in the document. This requires enabling format on save and
     # registering the ruby-lsp as the Ruby formatter.
     class Formatting < Request
-      extend T::Sig
-
       class Error < StandardError; end
 
       class << self
-        extend T::Sig
-
-        sig { returns(TrueClass) }
+        #: -> TrueClass
         def provider
           true
         end
       end
 
-      sig { params(global_state: GlobalState, document: RubyDocument).void }
+      #: (GlobalState global_state, RubyDocument document) -> void
       def initialize(global_state, document)
         super()
         @document = document
-        @active_formatter = T.let(global_state.active_formatter, T.nilable(Support::Formatter))
-        @uri = T.let(document.uri, URI::Generic)
+        @active_formatter = global_state.active_formatter #: Support::Formatter?
+        @uri = document.uri #: URI::Generic
       end
 
-      sig { override.returns(T.nilable(T.all(T::Array[Interface::TextEdit], Object))) }
+      # @override
+      #: -> (Array[Interface::TextEdit] & Object)?
       def perform
         return unless @active_formatter
         return if @document.syntax_error?

data/lib/ruby_lsp/requests/go_to_relevant_file.rb

@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # GoTo Relevant File is a custom [LSP
+    # request](https://microsoft.github.io/language-server-protocol/specification#requestMessage)
+    # that navigates to the relevant file for the current document.
+    # Currently, it supports source code file <> test file navigation.
+    class GoToRelevantFile < Request
+      TEST_KEYWORDS = ["test", "spec", "integration_test"]
+
+      TEST_PREFIX_PATTERN = /^(#{TEST_KEYWORDS.join("_|")}_)/
+      TEST_SUFFIX_PATTERN = /(_#{TEST_KEYWORDS.join("|_")})$/
+      TEST_PATTERN = /#{TEST_PREFIX_PATTERN}|#{TEST_SUFFIX_PATTERN}/
+
+      TEST_PREFIX_GLOB = "#{TEST_KEYWORDS.join("_,")}_" #: String
+      TEST_SUFFIX_GLOB = "_#{TEST_KEYWORDS.join(",_")}" #: String
+
+      #: (String path, String workspace_path) -> void
+      def initialize(path, workspace_path)
+        super()
+
+        @workspace_path = workspace_path
+        @path = path.delete_prefix(workspace_path) #: String
+      end
+
+      # @override
+      #: -> Array[String]
+      def perform
+        find_relevant_paths
+      end
+
+      private
+
+      #: -> Array[String]
+      def find_relevant_paths
+        candidate_paths = Dir.glob(File.join("**", relevant_filename_pattern))
+        return [] if candidate_paths.empty?
+
+        find_most_similar_with_jaccard(candidate_paths).map { File.join(@workspace_path, _1) }
+      end
+
+      #: -> String
+      def relevant_filename_pattern
+        input_basename = File.basename(@path, File.extname(@path))
+
+        relevant_basename_pattern =
+          if input_basename.match?(TEST_PATTERN)
+            input_basename.gsub(TEST_PATTERN, "")
+          else
+            "{{#{TEST_PREFIX_GLOB}}#{input_basename},#{input_basename}{#{TEST_SUFFIX_GLOB}}}"
+          end
+
+        "#{relevant_basename_pattern}#{File.extname(@path)}"
+      end
+
+      # Using the Jaccard algorithm to determine the similarity between the
+      # input path and the candidate relevant file paths.
+      # Ref: https://en.wikipedia.org/wiki/Jaccard_index
+      # The main idea of this algorithm is to take the size of interaction and divide
+      # it by the size of union between two sets (in our case the elements in each set
+      # would be the parts of the path separated by path divider.)
+      #: (Array[String] candidates) -> Array[String]
+      def find_most_similar_with_jaccard(candidates)
+        dirs = get_dir_parts(@path)
+
+        _, results = candidates
+          .group_by do |other_path|
+            other_dirs = get_dir_parts(other_path)
+            # Similarity score between the two directories
+            (dirs & other_dirs).size.to_f / (dirs | other_dirs).size
+          end
+          .max_by(&:first)
+
+        results || []
+      end
+
+      #: (String path) -> Set[String]
+      def get_dir_parts(path)
+        Set.new(File.dirname(path).split(File::SEPARATOR))
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/hover.rb

@@ -7,30 +7,16 @@ module RubyLsp
   module Requests
     # The [hover request](https://microsoft.github.io/language-server-protocol/specification#textDocument_hover)
     # displays the documentation for the symbol currently under the cursor.
+    #: [ResponseType = Interface::Hover?]
     class Hover < Request
-      extend T::Sig
-      extend T::Generic
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::HoverOptions) }
+        #: -> Interface::HoverOptions
         def provider
           Interface::HoverOptions.new
         end
       end
 
-      ResponseType = type_member { { fixed: T.nilable(Interface::Hover) } }
-
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
 
@@ -38,7 +24,7 @@ module RubyLsp
         delegate_request_if_needed!(global_state, document, char_position)
 
         node_context = RubyDocument.locate(
-          document.parse_result.value,
+          document.ast,
           char_position,
           node_types: Listeners::Hover::ALLOWED_TARGETS,
           code_units_cache: document.code_units_cache,
@@ -48,8 +34,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)
@@ -59,9 +45,9 @@ module RubyLsp
         # Don't need to instantiate any listeners if there's no target
         return unless target
 
-        @target = T.let(target, T.nilable(Prism::Node))
+        @target = target #: Prism::Node?
         uri = document.uri
-        @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
+        @response_builder = ResponseBuilders::Hover.new #: ResponseBuilders::Hover
         Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
@@ -70,7 +56,8 @@ module RubyLsp
         @dispatcher = dispatcher
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def perform
         return unless @target
 
@@ -88,14 +75,14 @@ module RubyLsp
 
       private
 
-      sig { params(parent: T.nilable(Prism::Node), target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Prism::Node? parent, Prism::Node? target) -> bool
       def should_refine_target?(parent, target)
         (Listeners::Hover::ALLOWED_TARGETS.include?(parent.class) &&
         !Listeners::Hover::ALLOWED_TARGETS.include?(target.class)) ||
           (parent.is_a?(Prism::ConstantPathNode) && target.is_a?(Prism::ConstantReadNode))
       end
 
-      sig { params(position: T::Hash[Symbol, T.untyped], target: T.nilable(Prism::Node)).returns(T::Boolean) }
+      #: (Hash[Symbol, untyped] position, Prism::Node? target) -> bool
       def position_outside_target?(position, target)
         case target
         when Prism::GlobalVariableAndWriteNode,

data/lib/ruby_lsp/requests/inlay_hints.rb

@@ -9,35 +9,24 @@ module RubyLsp
     # are labels added directly in the code that explicitly show the user something that might
     # otherwise just be implied.
     class InlayHints < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::InlayHintOptions) }
+        #: -> Interface::InlayHintOptions
         def provider
           Interface::InlayHintOptions.new(resolve_provider: false)
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          hints_configuration: RequestConfig,
-          dispatcher: Prism::Dispatcher,
-        ).void
-      end
-      def initialize(document, hints_configuration, dispatcher)
+      #: (GlobalState, (RubyDocument | ERBDocument), Prism::Dispatcher) -> void
+      def initialize(global_state, document, dispatcher)
         super()
 
-        @response_builder = T.let(
-          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint].new,
-          ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint],
-        )
-        Listeners::InlayHints.new(@response_builder, hints_configuration, dispatcher)
+        @response_builder = ResponseBuilders::CollectionResponseBuilder
+          .new #: ResponseBuilders::CollectionResponseBuilder[Interface::InlayHint]
+        Listeners::InlayHints.new(global_state, @response_builder, dispatcher)
       end
 
-      sig { override.returns(T::Array[Interface::InlayHint]) }
+      # @override
+      #: -> Array[Interface::InlayHint]
       def perform
         @response_builder.response
       end

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"