ruby-lsp 0.23.11 → 0.23.12

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

@@ -8,12 +8,11 @@ module RubyLsp
         # WARNING: Methods in this class may be used by Ruby LSP add-ons such as
         # https://github.com/Shopify/ruby-lsp-rails, or add-ons by created by developers outside of Shopify, so be
         # cautious of changing anything.
-        extend T::Sig
         extend T::Helpers
 
         requires_ancestor { Kernel }
 
-        sig { params(node: Prism::Node).returns(Interface::Range) }
+        #: (Prism::Node node) -> Interface::Range
         def range_from_node(node)
           loc = node.location
 
@@ -26,7 +25,7 @@ module RubyLsp
           )
         end
 
-        sig { params(location: T.any(Prism::Location, RubyIndexer::Location)).returns(Interface::Range) }
+        #: ((Prism::Location | RubyIndexer::Location) location) -> Interface::Range
         def range_from_location(location)
           Interface::Range.new(
             start: Interface::Position.new(
@@ -37,15 +36,7 @@ module RubyLsp
           )
         end
 
-        sig do
-          params(
-            node: Prism::Node,
-            title: String,
-            command_name: String,
-            arguments: T.nilable(T::Array[T.untyped]),
-            data: T.nilable(T::Hash[T.untyped, T.untyped]),
-          ).returns(Interface::CodeLens)
-        end
+        #: (Prism::Node node, title: String, command_name: String, arguments: Array[untyped]?, data: Hash[untyped, untyped]?) -> Interface::CodeLens
         def create_code_lens(node, title:, command_name:, arguments:, data:)
           range = range_from_node(node)
 
@@ -60,26 +51,20 @@ module RubyLsp
           )
         end
 
-        sig { params(file_path: String).returns(T.nilable(T::Boolean)) }
+        #: (String file_path) -> bool?
         def not_in_dependencies?(file_path)
           BUNDLE_PATH &&
             !file_path.start_with?(T.must(BUNDLE_PATH)) &&
             !file_path.start_with?(RbConfig::CONFIG["rubylibdir"])
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def self_receiver?(node)
           receiver = node.receiver
           receiver.nil? || receiver.is_a?(Prism::SelfNode)
         end
 
-        sig do
-          params(
-            title: String,
-            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-            max_entries: T.nilable(Integer),
-          ).returns(T::Hash[Symbol, String])
-        end
+        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries) -> Hash[Symbol, String]
         def categorized_markdown_from_index_entries(title, entries, max_entries = nil)
           markdown_title = "```ruby\n#{title}\n```"
           definitions = []
@@ -112,14 +97,7 @@ module RubyLsp
           }
         end
 
-        sig do
-          params(
-            title: String,
-            entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
-            max_entries: T.nilable(Integer),
-            extra_links: T.nilable(String),
-          ).returns(String)
-        end
+        #: (String title, (Array[RubyIndexer::Entry] | RubyIndexer::Entry) entries, ?Integer? max_entries, ?extra_links: String?) -> String
         def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
           categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
@@ -135,22 +113,12 @@ module RubyLsp
           MARKDOWN
         end
 
-        sig do
-          params(
-            node: T.any(
-              Prism::ConstantPathNode,
-              Prism::ConstantReadNode,
-              Prism::ConstantPathTargetNode,
-              Prism::CallNode,
-              Prism::MissingNode,
-            ),
-          ).returns(T.nilable(String))
-        end
+        #: ((Prism::ConstantPathNode | Prism::ConstantReadNode | Prism::ConstantPathTargetNode | Prism::CallNode | Prism::MissingNode) node) -> String?
         def constant_name(node)
           RubyIndexer::Index.constant_name(node)
         end
 
-        sig { params(node: T.any(Prism::ModuleNode, Prism::ClassNode)).returns(T.nilable(String)) }
+        #: ((Prism::ModuleNode | Prism::ClassNode) node) -> String?
         def namespace_constant_name(node)
           path = node.constant_path
           case path
@@ -162,12 +130,7 @@ module RubyLsp
         # Iterates over each part of a constant path, so that we can easily push response items for each section of the
         # name. For example, for `Foo::Bar::Baz`, this method will invoke the block with `Foo`, then `Bar` and finally
         # `Baz`.
-        sig do
-          params(
-            node: Prism::Node,
-            block: T.proc.params(part: Prism::Node).void,
-          ).void
-        end
+        #: (Prism::Node node) { (Prism::Node part) -> void } -> void
         def each_constant_path_part(node, &block)
           current = T.let(node, T.nilable(Prism::Node))
 
@@ -177,7 +140,7 @@ module RubyLsp
           end
         end
 
-        sig { params(entry: RubyIndexer::Entry).returns(T.nilable(Integer)) }
+        #: (RubyIndexer::Entry entry) -> Integer?
         def kind_for_entry(entry)
           case entry
           when RubyIndexer::Entry::Class
@@ -195,7 +158,7 @@ module RubyLsp
           end
         end
 
-        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
+        #: (RubyDocument::SorbetLevel sorbet_level) -> bool
         def sorbet_level_true_or_higher?(sorbet_level)
           sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
         end

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

@@ -5,8 +5,6 @@ module RubyLsp
   module Requests
     module Support
       class RuboCopDiagnostic
-        extend T::Sig
-
         RUBOCOP_TO_LSP_SEVERITY = T.let(
           {
             info: Constant::DiagnosticSeverity::HINT,
@@ -31,14 +29,14 @@ module RubyLsp
 
         # TODO: avoid passing document once we have alternative ways to get at
         # encoding and file source
-        sig { params(document: RubyDocument, offense: ::RuboCop::Cop::Offense, uri: URI::Generic).void }
+        #: (RubyDocument document, ::RuboCop::Cop::Offense offense, URI::Generic uri) -> void
         def initialize(document, offense, uri)
           @document = document
           @offense = offense
           @uri = uri
         end
 
-        sig { returns(T::Array[Interface::CodeAction]) }
+        #: -> Array[Interface::CodeAction]
         def to_lsp_code_actions
           code_actions = []
 
@@ -48,7 +46,7 @@ module RubyLsp
           code_actions
         end
 
-        sig { params(config: ::RuboCop::Config).returns(Interface::Diagnostic) }
+        #: (::RuboCop::Config config) -> Interface::Diagnostic
         def to_lsp_diagnostic(config)
           # highlighted_area contains the begin and end position of the first line
           # This ensures that multiline offenses don't clutter the editor
@@ -78,19 +76,19 @@ module RubyLsp
 
         private
 
-        sig { returns(String) }
+        #: -> String
         def message
           message  = @offense.message
           message += "\n\nThis offense is not auto-correctable.\n" unless correctable?
           message
         end
 
-        sig { returns(T.nilable(Integer)) }
+        #: -> Integer?
         def severity
           RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
         end
 
-        sig { params(config: ::RuboCop::Config).returns(T.nilable(Interface::CodeDescription)) }
+        #: (::RuboCop::Config config) -> Interface::CodeDescription?
         def code_description(config)
           cop = RuboCopRunner.find_cop_by_name(@offense.cop_name)
           return unless cop
@@ -103,7 +101,7 @@ module RubyLsp
           Interface::CodeDescription.new(href: doc_url) if doc_url
         end
 
-        sig { returns(Interface::CodeAction) }
+        #: -> Interface::CodeAction
         def autocorrect_action
           Interface::CodeAction.new(
             title: "Autocorrect #{@offense.cop_name}",
@@ -123,7 +121,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(T::Array[Interface::TextEdit]) }
+        #: -> Array[Interface::TextEdit]
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
             Interface::TextEdit.new(
@@ -136,7 +134,7 @@ module RubyLsp
           end
         end
 
-        sig { returns(Interface::CodeAction) }
+        #: -> Interface::CodeAction
         def disable_line_action
           Interface::CodeAction.new(
             title: "Disable #{@offense.cop_name} for this line",
@@ -155,7 +153,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(T::Array[Interface::TextEdit]) }
+        #: -> Array[Interface::TextEdit]
         def line_disable_comment
           new_text = if @offense.source_line.include?(" # rubocop:disable ")
             ",#{@offense.cop_name}"
@@ -178,7 +176,7 @@ module RubyLsp
           [inline_comment]
         end
 
-        sig { params(line: String).returns(Integer) }
+        #: (String line) -> Integer
         def length_of_line(line)
           if @document.encoding == Encoding::UTF_16LE
             line_length = 0
@@ -197,7 +195,7 @@ module RubyLsp
         # When `RuboCop::LSP.enable` is called, contextual autocorrect will not offer itself
         # as `correctable?` to prevent annoying changes while typing. Instead check if
         # a corrector is present. If it is, then that means some code transformation can be applied.
-        sig { returns(T::Boolean) }
+        #: -> bool
         def correctable?
           !@offense.corrector.nil?
         end

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

@@ -9,17 +9,17 @@ module RubyLsp
   module Requests
     module Support
       class RuboCopFormatter
-        extend T::Sig
         include Formatter
 
-        sig { void }
+        #: -> void
         def initialize
           @diagnostic_runner = T.let(RuboCopRunner.new, RuboCopRunner)
           # -a is for "--auto-correct" (or "--autocorrect" on newer versions of RuboCop)
           @format_runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
-        sig { override.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> String?
         def run_formatting(uri, document)
           filename = T.must(uri.to_standardized_path || uri.opaque)
 
@@ -29,17 +29,14 @@ module RubyLsp
         end
 
         # RuboCop does not support range formatting
-        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, String source, Integer base_indentation) -> String?
         def run_range_formatting(uri, source, base_indentation)
           nil
         end
 
-        sig do
-          override.params(
-            uri: URI::Generic,
-            document: RubyDocument,
-          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
-        end
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document)
           filename = T.must(uri.to_standardized_path || uri.opaque)
           # Invoke RuboCop with just this file in `paths`

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

@@ -32,15 +32,13 @@ module RubyLsp
   module Requests
     module Support
       class InternalRuboCopError < StandardError
-        extend T::Sig
-
         MESSAGE = <<~EOS
           An internal error occurred %s.
           Updating to a newer version of RuboCop may solve this.
           For more details, run RuboCop on the command line.
         EOS
 
-        sig { params(rubocop_error: T.any(::RuboCop::ErrorWithAnalyzedFileLocation, StandardError)).void }
+        #: ((::RuboCop::ErrorWithAnalyzedFileLocation | StandardError) rubocop_error) -> void
         def initialize(rubocop_error)
           message = case rubocop_error
           when ::RuboCop::ErrorWithAnalyzedFileLocation
@@ -54,8 +52,6 @@ module RubyLsp
 
       # :nodoc:
       class RuboCopRunner < ::RuboCop::Runner
-        extend T::Sig
-
         class ConfigurationError < StandardError; end
 
         DEFAULT_ARGS = T.let(
@@ -68,10 +64,10 @@ module RubyLsp
           T::Array[String],
         )
 
-        sig { returns(T::Array[::RuboCop::Cop::Offense]) }
+        #: Array[::RuboCop::Cop::Offense]
         attr_reader :offenses
 
-        sig { returns(::RuboCop::Config) }
+        #: ::RuboCop::Config
         attr_reader :config_for_working_directory
 
         begin
@@ -82,7 +78,7 @@ module RubyLsp
         end
         DEFAULT_ARGS.freeze
 
-        sig { params(args: String).void }
+        #: (*String args) -> void
         def initialize(*args)
           @options = T.let({}, T::Hash[Symbol, T.untyped])
           @offenses = T.let([], T::Array[::RuboCop::Cop::Offense])
@@ -99,7 +95,7 @@ module RubyLsp
           super(rubocop_options, config_store)
         end
 
-        sig { params(path: String, contents: String).void }
+        #: (String path, String contents) -> void
         def run(path, contents)
           # Clear Runner state between runs since we get a single instance of this class
           # on every use site.
@@ -121,22 +117,20 @@ module RubyLsp
           raise InternalRuboCopError, error
         end
 
-        sig { returns(String) }
+        #: -> String
         def formatted_source
           @options[:stdin]
         end
 
         class << self
-          extend T::Sig
-
-          sig { params(cop_name: String).returns(T.nilable(T.class_of(::RuboCop::Cop::Base))) }
+          #: (String cop_name) -> singleton(::RuboCop::Cop::Base)?
           def find_cop_by_name(cop_name)
             cop_registry[cop_name]&.first
           end
 
           private
 
-          sig { returns(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]) }
+          #: -> Hash[String, [singleton(::RuboCop::Cop::Base)]]
           def cop_registry
             @cop_registry ||= T.let(
               ::RuboCop::Cop::Registry.global.to_h,
@@ -147,7 +141,7 @@ module RubyLsp
 
         private
 
-        sig { params(_file: String, offenses: T::Array[::RuboCop::Cop::Offense]).void }
+        #: (String _file, Array[::RuboCop::Cop::Offense] offenses) -> void
         def file_finished(_file, offenses)
           @offenses = offenses
         end

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

@@ -5,9 +5,7 @@ module RubyLsp
   module Requests
     module Support
       class SelectionRange < Interface::SelectionRange
-        extend T::Sig
-
-        sig { params(position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+        #: (Hash[Symbol, untyped] position) -> bool
         def cover?(position)
           start_covered = range.start.line < position[:line] ||
             (range.start.line == position[:line] && range.start.character <= position[:character])

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

@@ -6,8 +6,6 @@ module RubyLsp
     module Support
       class Sorbet
         class << self
-          extend T::Sig
-
           ANNOTATIONS = T.let(
             {
               abstract!: Annotation.new(arity: 0),
@@ -40,11 +38,7 @@ module RubyLsp
             T::Hash[Symbol, Annotation],
           )
 
-          sig do
-            params(
-              node: Prism::CallNode,
-            ).returns(T::Boolean)
-          end
+          #: (Prism::CallNode node) -> bool
           def annotation?(node)
             !!ANNOTATIONS[node.name]&.match?(node)
           end

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

@@ -6,8 +6,6 @@ require "uri/file"
 module URI
   # Must be kept in sync with the one in Tapioca
   class Source < URI::File
-    extend T::Sig
-
     COMPONENT = T.let(
       [
         :scheme,
@@ -29,20 +27,11 @@ module URI
     T.unsafe(self).alias_method(:gem_name, :host)
     T.unsafe(self).alias_method(:line_number, :fragment)
 
-    sig { returns(T.nilable(String)) }
+    #: String?
     attr_reader :gem_version
 
     class << self
-      extend T::Sig
-
-      sig do
-        params(
-          gem_name: String,
-          gem_version: T.nilable(String),
-          path: String,
-          line_number: T.nilable(String),
-        ).returns(URI::Source)
-      end
+      #: (gem_name: String, gem_version: String?, path: String, line_number: String?) -> URI::Source
       def build(gem_name:, gem_version:, path:, line_number:)
         super(
           {
@@ -55,7 +44,7 @@ module URI
       end
     end
 
-    sig { params(v: T.nilable(String)).void }
+    #: (String? v) -> void
     def set_path(v) # rubocop:disable Naming/AccessorMethodName
       return if v.nil?
 
@@ -65,7 +54,7 @@ module URI
       @path = T.let(path, T.nilable(String))
     end
 
-    sig { params(v: T.nilable(String)).returns(T::Boolean) }
+    #: (String? v) -> bool
     def check_host(v)
       return true unless v
 
@@ -77,7 +66,7 @@ module URI
       true
     end
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
     end

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

@@ -13,10 +13,9 @@ module RubyLsp
     module Support
       # :nodoc:
       class SyntaxTreeFormatter
-        extend T::Sig
         include Support::Formatter
 
-        sig { void }
+        #: -> void
         def initialize
           @options =
             T.let(
@@ -29,7 +28,8 @@ module RubyLsp
             )
         end
 
-        sig { override.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> String?
         def run_formatting(uri, document)
           path = uri.to_standardized_path
           return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
@@ -37,7 +37,8 @@ module RubyLsp
           SyntaxTree.format(document.source, @options.print_width, options: @options.formatter_options)
         end
 
-        sig { override.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
+        # @override
+        #: (URI::Generic uri, String source, Integer base_indentation) -> String?
         def run_range_formatting(uri, source, base_indentation)
           path = uri.to_standardized_path
           return if path && @options.ignore_files.any? { |pattern| File.fnmatch?("*/#{pattern}", path) }
@@ -45,12 +46,8 @@ module RubyLsp
           SyntaxTree.format(source, @options.print_width, base_indentation, options: @options.formatter_options)
         end
 
-        sig do
-          override.params(
-            uri: URI::Generic,
-            document: RubyDocument,
-          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
-        end
+        # @override
+        #: (URI::Generic uri, RubyDocument document) -> Array[Interface::Diagnostic]?
         def run_diagnostic(uri, document)
           nil
         end

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

@@ -10,46 +10,47 @@ module RubyLsp
       # Note: this test item object can only represent test groups or examples discovered inside files. It cannot be
       # used to represent test files, directories or workspaces
       class TestItem
-        extend T::Sig
-
-        sig { returns(String) }
+        #: String
         attr_reader :id, :label
 
-        sig { params(id: String, label: String, uri: URI::Generic, range: Interface::Range).void }
-        def initialize(id, label, uri, range)
+        #: (String id, String label, URI::Generic uri, Interface::Range range, Array[Symbol] tags) -> void
+        def initialize(id, label, uri, range, tags: [])
           @id = id
           @label = label
           @uri = uri
           @range = range
+          @tags = tags
           @children = T.let({}, T::Hash[String, TestItem])
         end
 
-        sig { params(item: TestItem).void }
+        #: (TestItem item) -> void
         def add(item)
-          if @children.key?(item.id)
-            raise ResponseBuilders::TestCollection::DuplicateIdError, "TestItem ID is already in use"
-          end
-
           @children[item.id] = item
         end
 
-        sig { params(id: String).returns(T.nilable(TestItem)) }
+        #: (String id) -> TestItem?
         def [](id)
           @children[id]
         end
 
-        sig { returns(T::Array[TestItem]) }
+        #: -> Array[TestItem]
         def children
           @children.values
         end
 
-        sig { returns(T::Hash[Symbol, T.untyped]) }
+        #: (Symbol) -> bool
+        def tag?(tag)
+          @tags.include?(tag)
+        end
+
+        #: -> Hash[Symbol, untyped]
         def to_hash
           {
             id: @id,
             label: @label,
             uri: @uri,
             range: @range,
+            tags: @tags,
             children: children.map(&:to_hash),
           }
         end

data/lib/ruby_lsp/requests/type_hierarchy_supertypes.rb

@@ -7,11 +7,9 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#typeHierarchy_supertypes)
     # displays the list of ancestors (supertypes) for the selected type.
     class TypeHierarchySupertypes < Request
-      extend T::Sig
-
       include Support::Common
 
-      sig { params(index: RubyIndexer::Index, item: T::Hash[Symbol, T.untyped]).void }
+      #: (RubyIndexer::Index index, Hash[Symbol, untyped] item) -> void
       def initialize(index, item)
         super()
 
@@ -19,7 +17,8 @@ module RubyLsp
         @item = item
       end
 
-      sig { override.returns(T.nilable(T::Array[Interface::TypeHierarchyItem])) }
+      # @override
+      #: -> Array[Interface::TypeHierarchyItem]?
       def perform
         name = @item[:name]
         entries = @index[name]
@@ -60,7 +59,7 @@ module RubyLsp
 
       private
 
-      sig { params(entry: RubyIndexer::Entry).returns(Interface::TypeHierarchyItem) }
+      #: (RubyIndexer::Entry entry) -> Interface::TypeHierarchyItem
       def hierarchy_item(entry)
         Interface::TypeHierarchyItem.new(
           name: entry.name,

data/lib/ruby_lsp/requests/workspace_symbol.rb

@@ -7,10 +7,9 @@ module RubyLsp
     # request allows fuzzy searching declarations in the entire project. On VS Code, use CTRL/CMD + T to search for
     # symbols.
     class WorkspaceSymbol < Request
-      extend T::Sig
       include Support::Common
 
-      sig { params(global_state: GlobalState, query: T.nilable(String)).void }
+      #: (GlobalState global_state, String? query) -> void
       def initialize(global_state, query)
         super()
         @global_state = global_state
@@ -18,7 +17,8 @@ module RubyLsp
         @index = T.let(global_state.index, RubyIndexer::Index)
       end
 
-      sig { override.returns(T::Array[Interface::WorkspaceSymbol]) }
+      # @override
+      #: -> Array[Interface::WorkspaceSymbol]
       def perform
         @index.fuzzy_search(@query).filter_map do |entry|
           uri = entry.uri

data/lib/ruby_lsp/response_builders/collection_response_builder.rb

@@ -4,23 +4,23 @@
 module RubyLsp
   module ResponseBuilders
     class CollectionResponseBuilder < ResponseBuilder
-      extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { upper: Object } }
 
-      sig { void }
+      #: -> void
       def initialize
         super
         @items = T.let([], T::Array[ResponseType])
       end
 
-      sig { params(item: ResponseType).void }
+      #: (ResponseType item) -> void
       def <<(item)
         @items << item
       end
 
-      sig { override.returns(T::Array[ResponseType]) }
+      # @override
+      #: -> Array[ResponseType]
       def response
         @items
       end