ruby-lsp 0.23.10 → 0.23.14

data/lib/ruby_lsp/base_server.rb

@@ -8,30 +8,27 @@ module RubyLsp
 
     abstract!
 
-    sig { params(options: T.untyped).void }
+    #: (**untyped options) -> void
     def initialize(**options)
-      @test_mode = T.let(options[:test_mode], T.nilable(T::Boolean))
-      @setup_error = T.let(options[:setup_error], T.nilable(StandardError))
-      @install_error = T.let(options[:install_error], T.nilable(StandardError))
-      @writer = T.let(Transport::Stdio::Writer.new, Transport::Stdio::Writer)
-      @reader = T.let(Transport::Stdio::Reader.new, Transport::Stdio::Reader)
-      @incoming_queue = T.let(Thread::Queue.new, Thread::Queue)
-      @outgoing_queue = T.let(Thread::Queue.new, Thread::Queue)
-      @cancelled_requests = T.let([], T::Array[Integer])
-      @worker = T.let(new_worker, Thread)
-      @current_request_id = T.let(1, Integer)
-      @global_state = T.let(GlobalState.new, GlobalState)
-      @store = T.let(Store.new(@global_state), Store)
-      @outgoing_dispatcher = T.let(
-        Thread.new do
-          unless @test_mode
-            while (message = @outgoing_queue.pop)
-              @global_state.synchronize { @writer.write(message.to_hash) }
-            end
+      @test_mode = options[:test_mode] #: bool?
+      @setup_error = options[:setup_error] #: StandardError?
+      @install_error = options[:install_error] #: StandardError?
+      @writer = Transport::Stdio::Writer.new #: Transport::Stdio::Writer
+      @reader = Transport::Stdio::Reader.new #: Transport::Stdio::Reader
+      @incoming_queue = Thread::Queue.new #: Thread::Queue
+      @outgoing_queue = Thread::Queue.new #: Thread::Queue
+      @cancelled_requests = [] #: Array[Integer]
+      @worker = new_worker #: Thread
+      @current_request_id = 1 #: Integer
+      @global_state = GlobalState.new #: GlobalState
+      @store = Store.new(@global_state) #: Store
+      @outgoing_dispatcher = Thread.new do
+        unless @test_mode
+          while (message = @outgoing_queue.pop)
+            @global_state.synchronize { @writer.write(message.to_hash) }
           end
-        end,
-        Thread,
-      )
+        end
+      end #: Thread
 
       Thread.main.priority = 1
 
@@ -41,7 +38,7 @@ module RubyLsp
       process_message(initialize_request) if initialize_request
     end
 
-    sig { void }
+    #: -> void
     def start
       @reader.read do |message|
         method = message[:method]
@@ -90,7 +87,8 @@ module RubyLsp
         # The following requests need to be executed in the main thread directly to avoid concurrency issues. Everything
         # else is pushed into the incoming queue
         case method
-        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange"
+        when "initialize", "initialized", "textDocument/didOpen", "textDocument/didClose", "textDocument/didChange",
+          "rubyLsp/diagnoseState"
           process_message(message)
         when "shutdown"
           @global_state.synchronize do
@@ -107,7 +105,7 @@ module RubyLsp
       end
     end
 
-    sig { void }
+    #: -> void
     def run_shutdown
       @incoming_queue.clear
       @outgoing_queue.clear
@@ -121,13 +119,13 @@ module RubyLsp
     end
 
     # This method is only intended to be used in tests! Pops the latest response that would be sent to the client
-    sig { returns(T.untyped) }
+    #: -> untyped
     def pop_response
       @outgoing_queue.pop
     end
 
     # This method is only intended to be used in tests! Pushes a message to the incoming queue directly
-    sig { params(message: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] message) -> void
     def push_message(message)
       @incoming_queue << message
     end
@@ -138,16 +136,16 @@ module RubyLsp
     sig { abstract.void }
     def shutdown; end
 
-    sig { params(id: Integer, message: String, type: Integer).void }
+    #: (Integer id, String message, ?type: Integer) -> void
     def fail_request_and_notify(id, message, type: Constant::MessageType::INFO)
       send_message(Error.new(id: id, code: Constant::ErrorCodes::REQUEST_FAILED, message: message))
       send_message(Notification.window_show_message(message, type: type))
     end
 
-    sig { returns(Thread) }
+    #: -> Thread
     def new_worker
       Thread.new do
-        while (message = T.let(@incoming_queue.pop, T.nilable(T::Hash[Symbol, T.untyped])))
+        while (message = @incoming_queue.pop)
           id = message[:id]
 
           # Check if the request was cancelled before trying to process it
@@ -164,7 +162,7 @@ module RubyLsp
       end
     end
 
-    sig { params(message: T.any(Result, Error, Notification, Request)).void }
+    #: ((Result | Error | Notification | Request) message) -> void
     def send_message(message)
       # When we're shutting down the server, there's a small race condition between closing the thread queues and
       # finishing remaining requests. We may close the queue in the middle of processing a request, which will then fail
@@ -175,12 +173,12 @@ module RubyLsp
       @current_request_id += 1 if message.is_a?(Request)
     end
 
-    sig { params(id: Integer).void }
+    #: (Integer id) -> void
     def send_empty_response(id)
       send_message(Result.new(id: id, response: nil))
     end
 
-    sig { params(message: String, type: Integer).void }
+    #: (String message, ?type: Integer) -> void
     def send_log_message(message, type: Constant::MessageType::LOG)
       send_message(Notification.window_log_message(message, type: Constant::MessageType::LOG))
     end

data/lib/ruby_lsp/client_capabilities.rb

@@ -5,40 +5,38 @@ module RubyLsp
   # This class stores all client capabilities that the Ruby LSP and its add-ons depend on to ensure that we're
   # not enabling functionality unsupported by the editor connecting to the server
   class ClientCapabilities
-    extend T::Sig
-
-    sig { returns(T::Boolean) }
+    #: bool
     attr_reader :supports_watching_files,
       :supports_request_delegation,
       :window_show_message_supports_extra_properties,
       :supports_progress,
       :supports_diagnostic_refresh
 
-    sig { void }
+    #: -> void
     def initialize
       # The editor supports watching files. This requires two capabilities: dynamic registration and relative pattern
       # support
-      @supports_watching_files = T.let(false, T::Boolean)
+      @supports_watching_files = false #: bool
 
       # The editor supports request delegation. This is an experimental capability since request delegation has not been
       # standardized into the LSP spec yet
-      @supports_request_delegation = T.let(false, T::Boolean)
+      @supports_request_delegation = false #: bool
 
       # The editor supports extra arbitrary properties for `window/showMessageRequest`. Necessary for add-ons to show
       # dialogs with user interactions
-      @window_show_message_supports_extra_properties = T.let(false, T::Boolean)
+      @window_show_message_supports_extra_properties = false #: bool
 
       # Which resource operations the editor supports, like renaming files
-      @supported_resource_operations = T.let([], T::Array[String])
+      @supported_resource_operations = [] #: Array[String]
 
       # The editor supports displaying progress requests
-      @supports_progress = T.let(false, T::Boolean)
+      @supports_progress = false #: bool
 
       # The editor supports server initiated refresh for diagnostics
-      @supports_diagnostic_refresh = T.let(false, T::Boolean)
+      @supports_diagnostic_refresh = false #: bool
     end
 
-    sig { params(capabilities: T::Hash[Symbol, T.untyped]).void }
+    #: (Hash[Symbol, untyped] capabilities) -> void
     def apply_client_capabilities(capabilities)
       workspace_capabilities = capabilities[:workspace] || {}
 
@@ -65,7 +63,7 @@ module RubyLsp
       @supports_diagnostic_refresh = workspace_capabilities.dig(:diagnostics, :refreshSupport) || false
     end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def supports_rename?
       @supported_resource_operations.include?("rename")
     end

data/lib/ruby_lsp/document.rb

@@ -21,47 +21,47 @@ module RubyLsp
     # This maximum number of characters for providing expensive features, like semantic highlighting and diagnostics.
     # This is the same number used by the TypeScript extension in VS Code
     MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES = 100_000
-    EMPTY_CACHE = T.let(Object.new.freeze, Object)
+    EMPTY_CACHE = Object.new.freeze #: Object
 
     abstract!
 
-    sig { returns(ParseResultType) }
+    #: ParseResultType
     attr_reader :parse_result
 
-    sig { returns(String) }
+    #: String
     attr_reader :source
 
-    sig { returns(Integer) }
+    #: Integer
     attr_reader :version
 
-    sig { returns(URI::Generic) }
+    #: URI::Generic
     attr_reader :uri
 
-    sig { returns(Encoding) }
+    #: Encoding
     attr_reader :encoding
 
-    sig { returns(T.nilable(Edit)) }
+    #: Edit?
     attr_reader :last_edit
 
-    sig { returns(T.any(Interface::SemanticTokens, Object)) }
+    #: (Interface::SemanticTokens | Object)
     attr_accessor :semantic_tokens
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       @source = source
       @version = version
       @global_state = global_state
-      @cache = T.let(Hash.new(EMPTY_CACHE), T::Hash[String, T.untyped])
-      @semantic_tokens = T.let(EMPTY_CACHE, T.any(Interface::SemanticTokens, Object))
-      @encoding = T.let(global_state.encoding, Encoding)
-      @uri = T.let(uri, URI::Generic)
-      @needs_parsing = T.let(true, T::Boolean)
-      @parse_result = T.let(T.unsafe(nil), ParseResultType)
-      @last_edit = T.let(nil, T.nilable(Edit))
+      @cache = Hash.new(EMPTY_CACHE) #: Hash[String, untyped]
+      @semantic_tokens = EMPTY_CACHE #: (Interface::SemanticTokens | Object)
+      @encoding = global_state.encoding #: Encoding
+      @uri = uri #: URI::Generic
+      @needs_parsing = true #: bool
+      @parse_result = T.unsafe(nil) #: ParseResultType
+      @last_edit = nil #: Edit?
       parse!
     end
 
-    sig { params(other: Document[T.untyped]).returns(T::Boolean) }
+    #: (Document[untyped] other) -> bool
     def ==(other)
       self.class == other.class && uri == other.uri && @source == other.source
     end
@@ -69,13 +69,7 @@ module RubyLsp
     sig { abstract.returns(LanguageId) }
     def language_id; end
 
-    sig do
-      type_parameters(:T)
-        .params(
-          request_name: String,
-          block: T.proc.params(document: Document[ParseResultType]).returns(T.type_parameter(:T)),
-        ).returns(T.type_parameter(:T))
-    end
+    #: [T] (String request_name) { (Document[ParseResultType] document) -> T } -> T
     def cache_fetch(request_name, &block)
       cached = @cache[request_name]
       return cached if cached != EMPTY_CACHE
@@ -85,17 +79,17 @@ module RubyLsp
       result
     end
 
-    sig { type_parameters(:T).params(request_name: String, value: T.type_parameter(:T)).returns(T.type_parameter(:T)) }
+    #: [T] (String request_name, T value) -> T
     def cache_set(request_name, value)
       @cache[request_name] = value
     end
 
-    sig { params(request_name: String).returns(T.untyped) }
+    #: (String request_name) -> untyped
     def cache_get(request_name)
       @cache[request_name]
     end
 
-    sig { params(edits: T::Array[T::Hash[Symbol, T.untyped]], version: Integer).void }
+    #: (Array[Hash[Symbol, untyped]] edits, version: Integer) -> void
     def push_edits(edits, version:)
       edits.each do |edit|
         range = edit[:range]
@@ -132,17 +126,12 @@ module RubyLsp
     sig { abstract.returns(T::Boolean) }
     def syntax_error?; end
 
-    sig { returns(T::Boolean) }
+    #: -> bool
     def past_expensive_limit?
       @source.length > MAXIMUM_CHARACTERS_FOR_EXPENSIVE_FEATURES
     end
 
-    sig do
-      params(
-        start_pos: T::Hash[Symbol, T.untyped],
-        end_pos: T.nilable(T::Hash[Symbol, T.untyped]),
-      ).returns([Integer, T.nilable(Integer)])
-    end
+    #: (Hash[Symbol, untyped] start_pos, ?Hash[Symbol, untyped]? end_pos) -> [Integer, Integer?]
     def find_index_by_position(start_pos, end_pos = nil)
       @global_state.synchronize do
         scanner = create_scanner
@@ -154,7 +143,7 @@ module RubyLsp
 
     private
 
-    sig { returns(Scanner) }
+    #: -> Scanner
     def create_scanner
       Scanner.new(@source, @encoding)
     end
@@ -165,10 +154,10 @@ module RubyLsp
 
       abstract!
 
-      sig { returns(T::Hash[Symbol, T.untyped]) }
+      #: Hash[Symbol, untyped]
       attr_reader :range
 
-      sig { params(range: T::Hash[Symbol, T.untyped]).void }
+      #: (Hash[Symbol, untyped] range) -> void
       def initialize(range)
         @range = range
       end
@@ -181,20 +170,20 @@ module RubyLsp
     class Scanner
       extend T::Sig
 
-      LINE_BREAK = T.let(0x0A, Integer)
+      LINE_BREAK = 0x0A #: Integer
       # After character 0xFFFF, UTF-16 considers characters to have length 2 and we have to account for that
-      SURROGATE_PAIR_START = T.let(0xFFFF, Integer)
+      SURROGATE_PAIR_START = 0xFFFF #: Integer
 
-      sig { params(source: String, encoding: Encoding).void }
+      #: (String source, Encoding encoding) -> void
       def initialize(source, encoding)
-        @current_line = T.let(0, Integer)
-        @pos = T.let(0, Integer)
-        @source = T.let(source.codepoints, T::Array[Integer])
+        @current_line = 0 #: Integer
+        @pos = 0 #: Integer
+        @source = source.codepoints #: Array[Integer]
         @encoding = encoding
       end
 
       # Finds the character index inside the source string for a given line and column
-      sig { params(position: T::Hash[Symbol, T.untyped]).returns(Integer) }
+      #: (Hash[Symbol, untyped] position) -> Integer
       def find_char_position(position)
         # Find the character index for the beginning of the requested line
         until @current_line == position[:line]
@@ -224,7 +213,7 @@ module RubyLsp
 
       # Subtract 1 for each character after 0xFFFF in the current line from the column position, so that we hit the
       # right character in the UTF-8 representation
-      sig { params(current_position: Integer, requested_position: Integer).returns(Integer) }
+      #: (Integer current_position, Integer requested_position) -> Integer
       def utf_16_character_position_correction(current_position, requested_position)
         utf16_unicode_correction = 0
 

data/lib/ruby_lsp/erb_document.rb

@@ -3,35 +3,28 @@
 
 module RubyLsp
   class ERBDocument < Document
-    extend T::Sig
     extend T::Generic
 
     ParseResultType = type_member { { fixed: Prism::ParseResult } }
 
-    sig { returns(String) }
+    #: String
     attr_reader :host_language_source
 
-    sig do
-      returns(T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
-    end
+    #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     attr_reader :code_units_cache
 
-    sig { params(source: String, version: Integer, uri: URI::Generic, global_state: GlobalState).void }
+    #: (source: String, version: Integer, uri: URI::Generic, global_state: GlobalState) -> void
     def initialize(source:, version:, uri:, global_state:)
       # This has to be initialized before calling super because we call `parse` in the parent constructor, which
       # overrides this with the proper virtual host language source
-      @host_language_source = T.let("", String)
+      @host_language_source = "" #: String
       super
-      @code_units_cache = T.let(@parse_result.code_units_cache(@encoding), T.any(
-        T.proc.params(arg0: Integer).returns(Integer),
-        Prism::CodeUnitsCache,
-      ))
+      @code_units_cache =
+        @parse_result.code_units_cache(@encoding) #: (^(Integer arg0) -> Integer | Prism::CodeUnitsCache)
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def parse!
       return false unless @needs_parsing
 
@@ -46,22 +39,19 @@ module RubyLsp
       true
     end
 
-    sig { override.returns(T::Boolean) }
+    # @override
+    #: -> bool
     def syntax_error?
       @parse_result.failure?
     end
 
-    sig { override.returns(LanguageId) }
+    # @override
+    #: -> LanguageId
     def language_id
       LanguageId::ERB
     end
 
-    sig do
-      params(
-        position: T::Hash[Symbol, T.untyped],
-        node_types: T::Array[T.class_of(Prism::Node)],
-      ).returns(NodeContext)
-    end
+    #: (Hash[Symbol, untyped] position, ?node_types: Array[singleton(Prism::Node)]) -> NodeContext
     def locate_node(position, node_types: [])
       char_position, _ = find_index_by_position(position)
 
@@ -73,28 +63,26 @@ module RubyLsp
       )
     end
 
-    sig { params(char_position: Integer).returns(T.nilable(T::Boolean)) }
+    #: (Integer char_position) -> bool?
     def inside_host_language?(char_position)
       char = @host_language_source[char_position]
       char && char != " "
     end
 
     class ERBScanner
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :ruby, :host_language
 
-      sig { params(source: String).void }
+      #: (String source) -> void
       def initialize(source)
         @source = source
-        @host_language = T.let(+"", String)
-        @ruby = T.let(+"", String)
-        @current_pos = T.let(0, Integer)
-        @inside_ruby = T.let(false, T::Boolean)
+        @host_language = +"" #: String
+        @ruby = +"" #: String
+        @current_pos = 0 #: Integer
+        @inside_ruby = false #: bool
       end
 
-      sig { void }
+      #: -> void
       def scan
         while @current_pos < @source.length
           scan_char
@@ -104,7 +92,7 @@ module RubyLsp
 
       private
 
-      sig { void }
+      #: -> void
       def scan_char
         char = @source[@current_pos]
 
@@ -159,7 +147,7 @@ module RubyLsp
         end
       end
 
-      sig { params(char: String).void }
+      #: (String char) -> void
       def push_char(char)
         if @inside_ruby
           @ruby << char
@@ -170,7 +158,7 @@ module RubyLsp
         end
       end
 
-      sig { returns(String) }
+      #: -> String
       def next_char
         @source[@current_pos + 1] || ""
       end