ruby-lsp 0.23.11 → 0.26.1

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,24 +52,19 @@ module RubyLsp
 
       # :nodoc:
       class RuboCopRunner < ::RuboCop::Runner
-        extend T::Sig
-
         class ConfigurationError < StandardError; end
 
-        DEFAULT_ARGS = T.let(
-          [
-            "--stderr", # Print any output to stderr so that our stdout does not get polluted
-            "--force-exclusion",
-            "--format",
-            "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-          ],
-          T::Array[String],
-        )
-
-        sig { returns(T::Array[::RuboCop::Cop::Offense]) }
+        DEFAULT_ARGS = [
+          "--stderr", # Print any output to stderr so that our stdout does not get polluted
+          "--force-exclusion",
+          "--format",
+          "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
+        ] #: Array[String]
+
+        #: Array[::RuboCop::Cop::Offense]
         attr_reader :offenses
 
-        sig { returns(::RuboCop::Config) }
+        #: ::RuboCop::Config
         attr_reader :config_for_working_directory
 
         begin
@@ -82,25 +75,26 @@ 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])
-          @errors = T.let([], T::Array[String])
-          @warnings = T.let([], T::Array[String])
+          @options = {} #: Hash[Symbol, untyped]
+          @offenses = [] #: Array[::RuboCop::Cop::Offense]
+          @errors = [] #: Array[String]
+          @warnings = [] #: Array[String]
+          # @prism_result = nil #: Prism::ParseLexResult?
 
           args += DEFAULT_ARGS
           rubocop_options = ::RuboCop::Options.new.parse(args).first
 
           config_store = ::RuboCop::ConfigStore.new
           config_store.options_config = rubocop_options[:config] if rubocop_options[:config]
-          @config_for_working_directory = T.let(config_store.for_pwd, ::RuboCop::Config)
+          @config_for_working_directory = config_store.for_pwd #: ::RuboCop::Config
 
           super(rubocop_options, config_store)
         end
 
-        sig { params(path: String, contents: String).void }
-        def run(path, contents)
+        #: (String, String, Prism::ParseLexResult) -> void
+        def run(path, contents, prism_result)
           # Clear Runner state between runs since we get a single instance of this class
           # on every use site.
           @errors = []
@@ -108,6 +102,11 @@ module RubyLsp
           @offenses = []
           @options[:stdin] = contents
 
+          # Setting the Prism result before running the RuboCop runner makes it reuse the existing AST and avoids
+          # double-parsing. Unfortunately, this leads to a bunch of cops failing to execute properly under LSP mode.
+          # Uncomment this once reusing the Prism result is more stable
+          # @prism_result = prism_result
+
           super([path])
 
           # RuboCop rescues interrupts and then sets the `@aborting` variable to true. We don't want them to be rescued,
@@ -118,36 +117,35 @@ module RubyLsp
         rescue ::RuboCop::ValidationError => error
           raise ConfigurationError, error.message
         rescue StandardError => error
-          raise InternalRuboCopError, error
+          # Maintain the original backtrace so that debugging cops that are breaking is easier, but re-raise as a
+          # different error class
+          internal_error = InternalRuboCopError.new(error)
+          internal_error.set_backtrace(error.backtrace)
+          raise internal_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,
-              T.nilable(T::Hash[String, [T.class_of(::RuboCop::Cop::Base)]]),
-            )
+            @cop_registry ||= ::RuboCop::Cop::Registry.global.to_h #: Hash[String, [singleton(::RuboCop::Cop::Base)]]?
           end
         end
 
         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,45 +6,36 @@ module RubyLsp
     module Support
       class Sorbet
         class << self
-          extend T::Sig
+          ANNOTATIONS = {
+            abstract!: Annotation.new(arity: 0),
+            absurd: Annotation.new(arity: 1, receiver: true),
+            all: Annotation.new(arity: (2..), receiver: true),
+            any: Annotation.new(arity: (2..), receiver: true),
+            assert_type!: Annotation.new(arity: 2, receiver: true),
+            attached_class: Annotation.new(arity: 0, receiver: true),
+            bind: Annotation.new(arity: 2, receiver: true),
+            cast: Annotation.new(arity: 2, receiver: true),
+            class_of: Annotation.new(arity: 1, receiver: true),
+            enums: Annotation.new(arity: 0),
+            interface!: Annotation.new(arity: 0),
+            let: Annotation.new(arity: 2, receiver: true),
+            mixes_in_class_methods: Annotation.new(arity: 1),
+            must: Annotation.new(arity: 1, receiver: true),
+            must_because: Annotation.new(arity: 1, receiver: true),
+            nilable: Annotation.new(arity: 1, receiver: true),
+            noreturn: Annotation.new(arity: 0, receiver: true),
+            requires_ancestor: Annotation.new(arity: 0),
+            reveal_type: Annotation.new(arity: 1, receiver: true),
+            sealed!: Annotation.new(arity: 0),
+            self_type: Annotation.new(arity: 0, receiver: true),
+            sig: Annotation.new(arity: 0),
+            type_member: Annotation.new(arity: (0..1)),
+            type_template: Annotation.new(arity: 0),
+            unsafe: Annotation.new(arity: 1),
+            untyped: Annotation.new(arity: 0, receiver: true),
+          } #: Hash[Symbol, Annotation]
 
-          ANNOTATIONS = T.let(
-            {
-              abstract!: Annotation.new(arity: 0),
-              absurd: Annotation.new(arity: 1, receiver: true),
-              all: Annotation.new(arity: (2..), receiver: true),
-              any: Annotation.new(arity: (2..), receiver: true),
-              assert_type!: Annotation.new(arity: 2, receiver: true),
-              attached_class: Annotation.new(arity: 0, receiver: true),
-              bind: Annotation.new(arity: 2, receiver: true),
-              cast: Annotation.new(arity: 2, receiver: true),
-              class_of: Annotation.new(arity: 1, receiver: true),
-              enums: Annotation.new(arity: 0),
-              interface!: Annotation.new(arity: 0),
-              let: Annotation.new(arity: 2, receiver: true),
-              mixes_in_class_methods: Annotation.new(arity: 1),
-              must: Annotation.new(arity: 1, receiver: true),
-              must_because: Annotation.new(arity: 1, receiver: true),
-              nilable: Annotation.new(arity: 1, receiver: true),
-              noreturn: Annotation.new(arity: 0, receiver: true),
-              requires_ancestor: Annotation.new(arity: 0),
-              reveal_type: Annotation.new(arity: 1, receiver: true),
-              sealed!: Annotation.new(arity: 0),
-              self_type: Annotation.new(arity: 0, receiver: true),
-              sig: Annotation.new(arity: 0),
-              type_member: Annotation.new(arity: (0..1)),
-              type_template: Annotation.new(arity: 0),
-              unsafe: Annotation.new(arity: 1),
-              untyped: Annotation.new(arity: 0, receiver: true),
-            },
-            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,43 +6,31 @@ 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)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .alias_method(:gem_name, :host)
+    self #: as untyped # rubocop:disable Style/RedundantSelf
+      .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 +43,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 +65,7 @@ module URI
       true
     end
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       "source://#{gem_name}/#{gem_version}#{path}##{line_number}"
     end
@@ -85,7 +73,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 #: Hash[String, untyped] # rubocop:disable Style/ClassVars
       @@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,48 @@ 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)
+        #: URI::Generic
+        attr_reader :uri
+
+        #: Interface::Range
+        attr_reader :range
+
+        #: (String id, String label, URI::Generic uri, Interface::Range range, framework: Symbol) -> 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

@@ -3,24 +3,21 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType < Object]
     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

@@ -3,54 +3,48 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = Array[Interface::DocumentSymbol]]
     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)
+          @stack.pop #: as Interface::DocumentSymbol
         end
       end
 
-      sig { returns(T.any(SymbolHierarchyRoot, Interface::DocumentSymbol)) }
+      #: -> (SymbolHierarchyRoot | Interface::DocumentSymbol)
       def last
-        T.must(@stack.last)
+        @stack.last #: as !nil
       end
 
-      sig { override.returns(T::Array[Interface::DocumentSymbol]) }
+      # @override
+      #: -> Array[Interface::DocumentSymbol]
       def response
-        T.must(@stack.first).children
+        @stack.first #: as !nil
+          .children
       end
     end
   end

data/lib/ruby_lsp/response_builders/hover.rb

@@ -3,27 +3,20 @@
 
 module RubyLsp
   module ResponseBuilders
+    #: [ResponseType = String]
     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,14 +24,15 @@ 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 = @response[:title] #: as !nil
         result << "\n" << @response[:links] if @response[:links]
         result << "\n" << @response[:documentation] if @response[:documentation]