ruby-lsp 0.23.11 → 0.26.4

data/lib/ruby_lsp/requests/selection_ranges.rb

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

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -9,12 +9,8 @@ module RubyLsp
     # highlighting](https://microsoft.github.io/language-server-protocol/specification#textDocument_semanticTokens)
     # request informs the editor of the correct token types to provide consistent and accurate highlighting for themes.
     class SemanticHighlighting < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::SemanticTokensRegistrationOptions) }
+        #: -> Interface::SemanticTokensRegistrationOptions
         def provider
           Interface::SemanticTokensRegistrationOptions.new(
             document_selector: nil,
@@ -29,13 +25,7 @@ module RubyLsp
 
         # The compute_delta method receives the current semantic tokens and the previous semantic tokens and then tries
         # to compute the smallest possible semantic token edit that will turn previous into current
-        sig do
-          params(
-            current_tokens: T::Array[Integer],
-            previous_tokens: T::Array[Integer],
-            result_id: String,
-          ).returns(Interface::SemanticTokensDelta)
-        end
+        #: (Array[Integer] current_tokens, Array[Integer] previous_tokens, String result_id) -> Interface::SemanticTokensDelta
         def compute_delta(current_tokens, previous_tokens, result_id)
           # Find the index of the first token that is different between the two sets of tokens
           first_different_position = current_tokens.zip(previous_tokens).find_index { |new, old| new != old }
@@ -53,8 +43,8 @@ module RubyLsp
           # Filter the tokens based on the first different position. This must happen at this stage, before we try to
           # find the next position from the end or else we risk confusing sets of token that may have different lengths,
           # but end with the exact same token
-          old_tokens = T.must(previous_tokens[first_different_position...])
-          new_tokens = T.must(current_tokens[first_different_position...])
+          old_tokens = previous_tokens[first_different_position...] #: as !nil
+          new_tokens = current_tokens[first_different_position...] #: as !nil
 
           # Then search from the end to find the first token that doesn't match. Since the user is normally editing the
           # middle of the file, this will minimize the number of edits since the end of the token array has not changed
@@ -63,8 +53,8 @@ module RubyLsp
           end || 0
 
           # Filter the old and new tokens to only the section that will be replaced/inserted/deleted
-          old_tokens = T.must(old_tokens[...old_tokens.length - first_different_token_from_end])
-          new_tokens = T.must(new_tokens[...new_tokens.length - first_different_token_from_end])
+          old_tokens = old_tokens[...old_tokens.length - first_different_token_from_end] #: as !nil
+          new_tokens = new_tokens[...new_tokens.length - first_different_token_from_end] #: as !nil
 
           # And we send back a single edit, replacing an entire section for the new tokens
           Interface::SemanticTokensDelta.new(
@@ -73,7 +63,7 @@ module RubyLsp
           )
         end
 
-        sig { returns(Integer) }
+        #: -> Integer
         def next_result_id
           @mutex.synchronize do
             @result_id += 1
@@ -81,29 +71,19 @@ module RubyLsp
         end
       end
 
-      @result_id = T.let(0, Integer)
-      @mutex = T.let(Mutex.new, Mutex)
-
-      sig do
-        params(
-          global_state: GlobalState,
-          dispatcher: Prism::Dispatcher,
-          document: T.any(RubyDocument, ERBDocument),
-          previous_result_id: T.nilable(String),
-          range: T.nilable(T::Range[Integer]),
-        ).void
-      end
+      @result_id = 0 #: Integer
+      @mutex = Mutex.new #: Mutex
+
+      #: (GlobalState global_state, Prism::Dispatcher dispatcher, (RubyDocument | ERBDocument) document, String? previous_result_id, ?range: Range[Integer]?) -> void
       def initialize(global_state, dispatcher, document, previous_result_id, range: nil)
         super()
 
         @document = document
         @previous_result_id = previous_result_id
         @range = range
-        @result_id = T.let(SemanticHighlighting.next_result_id.to_s, String)
-        @response_builder = T.let(
-          ResponseBuilders::SemanticHighlighting.new(document.code_units_cache),
-          ResponseBuilders::SemanticHighlighting,
-        )
+        @result_id = SemanticHighlighting.next_result_id.to_s #: String
+        @response_builder = ResponseBuilders::SemanticHighlighting
+          .new(document.code_units_cache) #: ResponseBuilders::SemanticHighlighting
         Listeners::SemanticHighlighting.new(dispatcher, @response_builder)
 
         Addon.addons.each do |addon|
@@ -111,7 +91,8 @@ module RubyLsp
         end
       end
 
-      sig { override.returns(T.any(Interface::SemanticTokens, Interface::SemanticTokensDelta)) }
+      # @override
+      #: -> (Interface::SemanticTokens | Interface::SemanticTokensDelta)
       def perform
         previous_tokens = @document.semantic_tokens
         tokens = @response_builder.response

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -7,17 +7,16 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#requestMessage) that displays the AST
     # for the current document or for the current selection in a new tab.
     class ShowSyntaxTree < Request
-      extend T::Sig
-
-      sig { params(document: RubyDocument, range: T.nilable(T::Hash[Symbol, T.untyped])).void }
+      #: (RubyDocument document, Hash[Symbol, untyped]? range) -> void
       def initialize(document, range)
         super()
         @document = document
         @range = range
-        @tree = T.let(document.parse_result.value, Prism::ProgramNode)
+        @tree = document.ast #: Prism::ProgramNode
       end
 
-      sig { override.returns(String) }
+      # @override
+      #: -> String
       def perform
         return ast_for_range if @range
 
@@ -28,9 +27,9 @@ module RubyLsp
 
       private
 
-      sig { returns(String) }
+      #: -> String
       def ast_for_range
-        range = T.must(@range)
+        range = @range #: as !nil
         start_char, end_char = @document.find_index_by_position(range[:start], range[:end])
 
         queue = @tree.statements.body.dup
@@ -47,7 +46,7 @@ module RubyLsp
           if (start_char..end_char).cover?(loc.start_offset..loc.end_offset)
             found_nodes << node
           else
-            T.unsafe(queue).unshift(*node.child_nodes)
+            queue.unshift(*node.child_nodes)
           end
         end
 

data/lib/ruby_lsp/requests/signature_help.rb

@@ -9,12 +9,8 @@ module RubyLsp
     # request](https://microsoft.github.io/language-server-protocol/specification#textDocument_signatureHelp) displays
     # information about the parameters of a method as you type an invocation.
     class SignatureHelp < Request
-      extend T::Sig
-
       class << self
-        extend T::Sig
-
-        sig { returns(Interface::SignatureHelpOptions) }
+        #: -> Interface::SignatureHelpOptions
         def provider
           # Identifier characters are automatically included, such as A-Z, a-z, 0-9, _, * or :
           Interface::SignatureHelpOptions.new(
@@ -23,16 +19,7 @@ module RubyLsp
         end
       end
 
-      sig do
-        params(
-          document: T.any(RubyDocument, ERBDocument),
-          global_state: GlobalState,
-          position: T::Hash[Symbol, T.untyped],
-          context: T.nilable(T::Hash[Symbol, T.untyped]),
-          dispatcher: Prism::Dispatcher,
-          sorbet_level: RubyDocument::SorbetLevel,
-        ).void
-      end
+      #: ((RubyDocument | ERBDocument) document, GlobalState global_state, Hash[Symbol, untyped] position, Hash[Symbol, untyped]? context, Prism::Dispatcher dispatcher, SorbetLevel sorbet_level) -> void
       def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
 
@@ -40,7 +27,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: [Prism::CallNode],
           code_units_cache: document.code_units_cache,
@@ -48,13 +35,14 @@ module RubyLsp
 
         target = adjust_for_nested_target(node_context.node, node_context.parent, position)
 
-        @target = T.let(target, T.nilable(Prism::Node))
+        @target = target #: Prism::Node?
         @dispatcher = dispatcher
-        @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
+        @response_builder = ResponseBuilders::SignatureHelp.new #: ResponseBuilders::SignatureHelp
         Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, sorbet_level)
       end
 
-      sig { override.returns(T.nilable(Interface::SignatureHelp)) }
+      # @override
+      #: -> Interface::SignatureHelp?
       def perform
         return unless @target
 
@@ -70,13 +58,7 @@ module RubyLsp
       # foo(another_method_call)
       #
       # In that case, we want to provide signature help for `foo` and not `another_method_call`.
-      sig do
-        params(
-          target: T.nilable(Prism::Node),
-          parent: T.nilable(Prism::Node),
-          position: T::Hash[Symbol, T.untyped],
-        ).returns(T.nilable(Prism::Node))
-      end
+      #: (Prism::Node? target, Prism::Node? parent, Hash[Symbol, untyped] position) -> Prism::Node?
       def adjust_for_nested_target(target, parent, position)
         # If the parent node is not a method call, then make no adjustments
         return target unless parent.is_a?(Prism::CallNode)
@@ -92,7 +74,7 @@ module RubyLsp
         arguments.nil? || !node_covers?(arguments, position) ? parent : target
       end
 
-      sig { params(node: Prism::Node, position: T::Hash[Symbol, T.untyped]).returns(T::Boolean) }
+      #: (Prism::Node node, Hash[Symbol, untyped] position) -> bool
       def node_covers?(node, position)
         location = node.location
         start_line = location.start_line - 1

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

@@ -5,32 +5,26 @@ module RubyLsp
   module Requests
     module Support
       class Annotation
-        extend T::Sig
-        sig do
-          params(
-            arity: T.any(Integer, T::Range[Integer]),
-            receiver: T::Boolean,
-          ).void
-        end
+        #: (arity: (Integer | Range[Integer]), ?receiver: bool) -> void
         def initialize(arity:, receiver: false)
           @arity = arity
           @receiver = receiver
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def match?(node)
           receiver_matches?(node) && arity_matches?(node)
         end
 
         private
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def receiver_matches?(node)
           node_receiver = node.receiver
           (node_receiver && @receiver && node_receiver.location.slice == "T") || (!node_receiver && !@receiver)
         end
 
-        sig { params(node: Prism::CallNode).returns(T::Boolean) }
+        #: (Prism::CallNode node) -> bool
         def arity_matches?(node)
           node_arity = node.arguments&.arguments&.size || 0
 

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

@@ -4,16 +4,13 @@
 module RubyLsp
   module Requests
     module Support
+      # @requires_ancestor: Kernel
       module Common
         # 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 +23,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 +34,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 +49,22 @@ 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?(
+              BUNDLE_PATH, #: as !nil
+            ) &&
             !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,14 +130,9 @@ 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))
+          current = node #: Prism::Node?
 
           while current.is_a?(Prism::ConstantPathNode)
             block.call(current)
@@ -177,28 +140,27 @@ 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
             Constant::SymbolKind::CLASS
           when RubyIndexer::Entry::Module
             Constant::SymbolKind::NAMESPACE
-          when RubyIndexer::Entry::Constant
+          when RubyIndexer::Entry::Constant, RubyIndexer::Entry::UnresolvedConstantAlias, RubyIndexer::Entry::ConstantAlias
             Constant::SymbolKind::CONSTANT
-          when RubyIndexer::Entry::Method
+          when RubyIndexer::Entry::Method, RubyIndexer::Entry::UnresolvedMethodAlias, RubyIndexer::Entry::MethodAlias
             entry.name == "initialize" ? Constant::SymbolKind::CONSTRUCTOR : Constant::SymbolKind::METHOD
           when RubyIndexer::Entry::Accessor
             Constant::SymbolKind::PROPERTY
-          when RubyIndexer::Entry::InstanceVariable
+          when RubyIndexer::Entry::InstanceVariable, RubyIndexer::Entry::ClassVariable
             Constant::SymbolKind::FIELD
+          when RubyIndexer::Entry::GlobalVariable
+            Constant::SymbolKind::VARIABLE
+          else
+            Constant::SymbolKind::NULL
           end
         end
-
-        sig { params(sorbet_level: RubyDocument::SorbetLevel).returns(T::Boolean) }
-        def sorbet_level_true_or_higher?(sorbet_level)
-          sorbet_level == RubyDocument::SorbetLevel::True || sorbet_level == RubyDocument::SorbetLevel::Strict
-        end
       end
     end
   end

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

@@ -4,25 +4,26 @@
 module RubyLsp
   module Requests
     module Support
+      # Empty module to avoid the runtime component. This is an interface defined in sorbet/rbi/shims/ruby_lsp.rbi
+      # @interface
       module Formatter
-        extend T::Sig
-        extend T::Helpers
-
-        interface!
-
-        sig { abstract.params(uri: URI::Generic, document: RubyDocument).returns(T.nilable(String)) }
-        def run_formatting(uri, document); end
+        # @abstract
+        #: (URI::Generic, RubyLsp::RubyDocument) -> String?
+        def run_formatting(uri, document)
+          raise AbstractMethodInvokedError
+        end
 
-        sig { abstract.params(uri: URI::Generic, source: String, base_indentation: Integer).returns(T.nilable(String)) }
-        def run_range_formatting(uri, source, base_indentation); end
+        # @abstract
+        #: (URI::Generic, String, Integer) -> String?
+        def run_range_formatting(uri, source, base_indentation)
+          raise AbstractMethodInvokedError
+        end
 
-        sig do
-          abstract.params(
-            uri: URI::Generic,
-            document: RubyDocument,
-          ).returns(T.nilable(T::Array[Interface::Diagnostic]))
+        # @abstract
+        #: (URI::Generic, RubyLsp::RubyDocument) -> Array[Interface::Diagnostic]?
+        def run_diagnostic(uri, document)
+          raise AbstractMethodInvokedError
         end
-        def run_diagnostic(uri, document); end
       end
     end
   end