ruby-lsp 0.23.11 → 0.23.13

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

@@ -6,43 +6,29 @@ 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,
-        :gem_name,
-        :gem_version,
-        :path,
-        :line_number,
-      ].freeze,
-      T::Array[Symbol],
-    )
+    COMPONENT = [
+      :scheme,
+      :gem_name,
+      :gem_version,
+      :path,
+      :line_number,
+    ].freeze #: Array[Symbol]
 
     # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation
     # warning on a few methods and delegates them to RFC2396, namely `extract`/`make_regexp`/`escape`/`unescape`.
     # On earlier versions of the uri gem, the RFC2396_PARSER constant doesn't exist, so it needs some special
     # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may
     # have the uri gem in their own bundle and thus not use a compatible version.
-    PARSER = T.let(const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER, RFC2396_Parser)
+    PARSER = const_defined?(:RFC2396_PARSER) ? RFC2396_PARSER : DEFAULT_PARSER #: RFC2396_Parser
 
     T.unsafe(self).alias_method(:gem_name, :host)
     T.unsafe(self).alias_method(:line_number, :fragment)
 
-    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,17 +41,17 @@ 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?
 
       gem_version, path = v.delete_prefix("/").split("/", 2)
 
-      @gem_version = T.let(gem_version, T.nilable(String))
-      @path = T.let(path, T.nilable(String))
+      @gem_version = gem_version #: String?
+      @path = path #: String?
     end
 
-    sig { params(v: T.nilable(String)).returns(T::Boolean) }
+    #: (String? v) -> bool
     def check_host(v)
       return true unless v
 
@@ -77,7 +63,7 @@ module URI
       true
     end
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
     end
@@ -85,7 +71,7 @@ module URI
     if URI.respond_to?(:register_scheme)
       URI.register_scheme("SOURCE", self)
     else
-      @@schemes = T.let(@@schemes, T::Hash[String, T.untyped]) # rubocop:disable Style/ClassVars
+      @@schemes = @@schemes # rubocop:disable Style/ClassVars #: Hash[String, untyped]
       @@schemes["SOURCE"] = self
     end
   end

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

@@ -13,23 +13,19 @@ module RubyLsp
     module Support
       # :nodoc:
       class SyntaxTreeFormatter
-        extend T::Sig
         include Support::Formatter
 
-        sig { void }
+        #: -> void
         def initialize
-          @options =
-            T.let(
-              begin
-                opts = SyntaxTree::CLI::Options.new
-                opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
-                opts
-              end,
-              SyntaxTree::CLI::Options,
-            )
+          @options = begin
+            opts = SyntaxTree::CLI::Options.new
+            opts.parse(SyntaxTree::CLI::ConfigFile.new.arguments)
+            opts
+          end #: SyntaxTree::CLI::Options
         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 +33,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 +42,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,42 @@ 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, Symbol framework) -> void
+        def initialize(id, label, uri, range, framework:)
           @id = id
           @label = label
           @uri = uri
           @range = range
-          @children = T.let({}, T::Hash[String, TestItem])
+          @tags = ["framework:#{framework}"] #: Array[String]
+          @children = {} #: 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]) }
+        #: -> 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,12 +17,13 @@ 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]
 
-        parents = T.let(Set.new, T::Set[RubyIndexer::Entry::Namespace])
+        parents = Set.new #: Set[RubyIndexer::Entry::Namespace]
         return unless entries&.any?
 
         entries.each do |entry|
@@ -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,18 +7,18 @@ 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
         @query = query
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @index = 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])
+        @items = [] #: 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

data/lib/ruby_lsp/response_builders/document_symbol.rb

@@ -4,51 +4,45 @@
 module RubyLsp
   module ResponseBuilders
     class DocumentSymbol < ResponseBuilder
-      extend T::Sig
-
       ResponseType = type_member { { fixed: T::Array[Interface::DocumentSymbol] } }
 
       class SymbolHierarchyRoot
-        extend T::Sig
-
-        sig { returns(T::Array[Interface::DocumentSymbol]) }
+        #: Array[Interface::DocumentSymbol]
         attr_reader :children
 
-        sig { void }
+        #: -> void
         def initialize
-          @children = T.let([], T::Array[Interface::DocumentSymbol])
+          @children = [] #: Array[Interface::DocumentSymbol]
         end
       end
 
-      sig { void }
+      #: -> void
       def initialize
         super
-        @stack = T.let(
-          [SymbolHierarchyRoot.new],
-          T::Array[T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)],
-        )
+        @stack = [SymbolHierarchyRoot.new] #: Array[(SymbolHierarchyRoot | Interface::DocumentSymbol)]
       end
 
-      sig { params(symbol: Interface::DocumentSymbol).void }
+      #: (Interface::DocumentSymbol symbol) -> void
       def push(symbol)
         @stack << symbol
       end
 
       alias_method(:<<, :push)
 
-      sig { returns(T.nilable(Interface::DocumentSymbol)) }
+      #: -> Interface::DocumentSymbol?
       def pop
         if @stack.size > 1
           T.cast(@stack.pop, Interface::DocumentSymbol)
         end
       end
 
-      sig { returns(T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)) }
+      #: -> (SymbolHierarchyRoot | Interface::DocumentSymbol)
       def last
         T.must(@stack.last)
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      # @override
+      #: -> Array[Interface::DocumentSymbol]
       def response
         T.must(@stack.first).children
       end

data/lib/ruby_lsp/response_builders/hover.rb

@@ -4,26 +4,22 @@
 module RubyLsp
   module ResponseBuilders
     class Hover < ResponseBuilder
-      extend T::Sig
       extend T::Generic
 
       ResponseType = type_member { { fixed: String } }
 
-      sig { void }
+      #: -> void
       def initialize
         super
 
-        @response = T.let(
-          {
-            title: +"",
-            links: +"",
-            documentation: +"",
-          },
-          T::Hash[Symbol, String],
-        )
+        @response = {
+          title: +"",
+          links: +"",
+          documentation: +"",
+        } #: Hash[Symbol, String]
       end
 
-      sig { params(content: String, category: Symbol).void }
+      #: (String content, category: Symbol) -> void
       def push(content, category:)
         hover_content = @response[category]
         if hover_content
@@ -31,12 +27,13 @@ module RubyLsp
         end
       end
 
-      sig { returns(T::Boolean) }
+      #: -> bool
       def empty?
         @response.values.all?(&:empty?)
       end
 
-      sig { override.returns(ResponseType) }
+      # @override
+      #: -> ResponseType
       def response
         result = T.must(@response[:title])
         result << "\n" << @response[:links] if @response[:links]

data/lib/ruby_lsp/response_builders/response_builder.rb

@@ -4,8 +4,8 @@
 module RubyLsp
   module ResponseBuilders
     class ResponseBuilder
-      extend T::Sig
       extend T::Generic
+      extend T::Sig
 
       abstract!
 

data/lib/ruby_lsp/response_builders/semantic_highlighting.rb

@@ -6,68 +6,55 @@ module RubyLsp
     class SemanticHighlighting < ResponseBuilder
       class UndefinedTokenType < StandardError; end
 
-      extend T::Sig
-
-      TOKEN_TYPES = T.let(
-        {
-          namespace: 0,
-          type: 1,
-          class: 2,
-          enum: 3,
-          interface: 4,
-          struct: 5,
-          typeParameter: 6,
-          parameter: 7,
-          variable: 8,
-          property: 9,
-          enumMember: 10,
-          event: 11,
-          function: 12,
-          method: 13,
-          macro: 14,
-          keyword: 15,
-          modifier: 16,
-          comment: 17,
-          string: 18,
-          number: 19,
-          regexp: 20,
-          operator: 21,
-          decorator: 22,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
-
-      TOKEN_MODIFIERS = T.let(
-        {
-          declaration: 0,
-          definition: 1,
-          readonly: 2,
-          static: 3,
-          deprecated: 4,
-          abstract: 5,
-          async: 6,
-          modification: 7,
-          documentation: 8,
-          default_library: 9,
-        }.freeze,
-        T::Hash[Symbol, Integer],
-      )
+      TOKEN_TYPES = {
+        namespace: 0,
+        type: 1,
+        class: 2,
+        enum: 3,
+        interface: 4,
+        struct: 5,
+        typeParameter: 6,
+        parameter: 7,
+        variable: 8,
+        property: 9,
+        enumMember: 10,
+        event: 11,
+        function: 12,
+        method: 13,
+        macro: 14,
+        keyword: 15,
+        modifier: 16,
+        comment: 17,
+        string: 18,
+        number: 19,
+        regexp: 20,
+        operator: 21,
+        decorator: 22,
+      }.freeze #: Hash[Symbol, Integer]
+
+      TOKEN_MODIFIERS = {
+        declaration: 0,
+        definition: 1,
+        readonly: 2,
+        static: 3,
+        deprecated: 4,
+        abstract: 5,
+        async: 6,
+        modification: 7,
+        documentation: 8,
+        default_library: 9,
+      }.freeze #: Hash[Symbol, Integer]
 
       ResponseType = type_member { { fixed: Interface::SemanticTokens } }
 
-      sig do
-        params(code_units_cache: T.any(
-          T.proc.params(arg0: Integer).returns(Integer),
-          Prism::CodeUnitsCache,
-        )).void
-      end
+      #: ((^(Integer arg0) -> Integer | Prism::CodeUnitsCache) code_units_cache) -> void
       def initialize(code_units_cache)
         super()
         @code_units_cache = code_units_cache
-        @stack = T.let([], T::Array[SemanticToken])
+        @stack = [] #: Array[SemanticToken]
       end
 
-      sig { params(location: Prism::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      #: (Prism::Location location, Symbol type, ?Array[Symbol] modifiers) -> void
       def add_token(location, type, modifiers = [])
         end_code_unit = location.cached_end_code_units_offset(@code_units_cache)
         length = end_code_unit - location.cached_start_code_units_offset(@code_units_cache)
@@ -83,7 +70,7 @@ module RubyLsp
         )
       end
 
-      sig { params(location: Prism::Location).returns(T::Boolean) }
+      #: (Prism::Location location) -> bool
       def last_token_matches?(location)
         token = @stack.last
         return false unless token
@@ -92,43 +79,34 @@ module RubyLsp
           token.start_code_unit_column == location.cached_start_code_units_column(@code_units_cache)
       end
 
-      sig { returns(T.nilable(SemanticToken)) }
+      #: -> SemanticToken?
       def last
         @stack.last
       end
 
-      sig { override.returns(T::Array[SemanticToken]) }
+      # @override
+      #: -> Array[SemanticToken]
       def response
         @stack
       end
 
       class SemanticToken
-        extend T::Sig
-
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :start_line
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :start_code_unit_column
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :length
 
-        sig { returns(Integer) }
+        #: Integer
         attr_reader :type
 
-        sig { returns(T::Array[Integer]) }
+        #: Array[Integer]
         attr_reader :modifier
 
-        sig do
-          params(
-            start_line: Integer,
-            start_code_unit_column: Integer,
-            length: Integer,
-            type: Integer,
-            modifier: T::Array[Integer],
-          ).void
-        end
+        #: (start_line: Integer, start_code_unit_column: Integer, length: Integer, type: Integer, modifier: Array[Integer]) -> void
         def initialize(start_line:, start_code_unit_column:, length:, type:, modifier:)
           @start_line = start_line
           @start_code_unit_column = start_code_unit_column
@@ -137,7 +115,7 @@ module RubyLsp
           @modifier = modifier
         end
 
-        sig { params(type_symbol: Symbol).void }
+        #: (Symbol type_symbol) -> void
         def replace_type(type_symbol)
           type_int = TOKEN_TYPES[type_symbol]
           raise UndefinedTokenType, "Undefined token type: #{type_symbol}" unless type_int
@@ -145,7 +123,7 @@ module RubyLsp
           @type = type_int
         end
 
-        sig { params(modifier_symbols: T::Array[Symbol]).void }
+        #: (Array[Symbol] modifier_symbols) -> void
         def replace_modifier(modifier_symbols)
           @modifier = modifier_symbols.filter_map do |modifier_symbol|
             modifier_index = TOKEN_MODIFIERS[modifier_symbol]
@@ -157,19 +135,13 @@ module RubyLsp
       end
 
       class SemanticTokenEncoder
-        extend T::Sig
-
-        sig { void }
+        #: -> void
         def initialize
-          @current_row = T.let(0, Integer)
-          @current_column = T.let(0, Integer)
+          @current_row = 0 #: Integer
+          @current_column = 0 #: Integer
         end
 
-        sig do
-          params(
-            tokens: T::Array[SemanticToken],
-          ).returns(T::Array[Integer])
-        end
+        #: (Array[SemanticToken] tokens) -> Array[Integer]
         def encode(tokens)
           sorted_tokens = tokens.sort_by.with_index do |token, index|
             # Enumerable#sort_by is not deterministic when the compared values are equal.
@@ -194,7 +166,7 @@ module RubyLsp
 
         # For more information on how each number is calculated, read:
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
-        sig { params(token: SemanticToken).returns(T::Array[Integer]) }
+        #: (SemanticToken token) -> Array[Integer]
         def compute_delta(token)
           row = token.start_line - 1
           column = token.start_code_unit_column
@@ -216,7 +188,7 @@ module RubyLsp
         # For example, [:default_library] will be encoded as
         # 0b1000000000, as :default_library is the 10th bit according
         # to the token modifiers index map.
-        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
+        #: (Array[Integer] modifiers) -> Integer
         def encode_modifiers(modifiers)
           modifiers.inject(0) do |encoded_modifiers, modifier|
             encoded_modifiers | (1 << modifier)