Migrate to RBS in comments syntax (#600)

Author: vinistock

lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -28,24 +28,25 @@ def initialize
 
         # We first initialize the client as a NullClient, so that we can start the server in a background thread. Until
         # the real client is initialized, features that depend on it will not be blocked by using the NullClient
-        @rails_runner_client = T.let(NullClient.new, RunnerClient)
-        @global_state = T.let(nil, T.nilable(GlobalState))
-        @outgoing_queue = T.let(nil, T.nilable(Thread::Queue))
-        @settings = T.let(
-          {
-            enablePendingMigrationsPrompt: true,
-          },
-          T::Hash[Symbol, T.untyped],
-        )
-        @addon_mutex = T.let(Mutex.new, Mutex)
-        @client_mutex = T.let(Mutex.new, Mutex)
+        @rails_runner_client = NullClient.new #: RunnerClient
+        @global_state = nil #: GlobalState?
+        @outgoing_queue = nil #: Thread::Queue?
+        @settings = {
+          enablePendingMigrationsPrompt: true,
+        } #: Hash[Symbol, untyped],
+
+        @addon_mutex = Mutex.new #: Mutex
+        @client_mutex = Mutex.new #: Mutex
         @client_mutex.lock
 
         Thread.new do
           @addon_mutex.synchronize do
             # We need to ensure the Rails client is fully loaded before we activate the server addons
             @client_mutex.synchronize do
-              @rails_runner_client = RunnerClient.create_client(T.must(@outgoing_queue), T.must(@global_state))
+              @rails_runner_client = RunnerClient.create_client(
+                @outgoing_queue, #: as !nil
+                @global_state, #: as !nil
+              )
             end
             offer_to_run_pending_migrations
           end

lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -80,10 +80,10 @@ def initialize(client, global_state, response_builder, uri, dispatcher)
         @client = client
         @global_state = global_state
         @response_builder = response_builder
-        @path = T.let(uri.to_standardized_path, T.nilable(String))
-        @group_id = T.let(1, Integer)
-        @group_id_stack = T.let([], T::Array[Integer])
-        @constant_name_stack = T.let([], T::Array[[String, T.nilable(String)]])
+        @path = uri.to_standardized_path #: String?
+        @group_id = 1 #: Integer
+        @group_id_stack = [] #: Array[Integer]
+        @constant_name_stack = [] #: Array[[String, String?]]
 
         dispatcher.register(
           self,
@@ -209,7 +209,7 @@ def add_jump_to_view(node)
 
       #: (Prism::DefNode node) -> void
       def add_route_code_lens_to_action(node)
-        class_name, _ = T.must(@constant_name_stack.last)
+        class_name, _ = @constant_name_stack.last #: as !nil
         route = @client.route(controller: class_name, action: node.name.to_s)
         return unless route
 
@@ -236,7 +236,9 @@ def migrate_command
 
       #: -> String?
       def migration_version
-        File.basename(T.must(@path)).split("_").first
+        File.basename(
+          @path, #: as !nil
+        ).split("_").first
       end
 
       #: (Prism::Node node, name: String, command: String) -> void

lib/ruby_lsp/ruby_lsp_rails/completion.rb

@@ -37,7 +37,7 @@ def handle_active_record_where_completions(node:, receiver:)
         return if resolved_class.nil?
 
         arguments = @node_context.call_node.arguments&.arguments
-        indexed_call_node_args = T.let({}, T::Hash[String, Prism::Node])
+        indexed_call_node_args = {} #: Hash[String, Prism::Node]
 
         if arguments
           indexed_call_node_args = index_call_node_args(arguments: arguments)

lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -35,7 +35,7 @@ def initialize(client, response_builder, node_context, index, dispatcher)
         @client = client
         @response_builder = response_builder
         @node_context = node_context
-        @nesting = T.let(node_context.nesting, T::Array[String])
+        @nesting = node_context.nesting #: Array[String]
         @index = index
 
         dispatcher.register(self, :on_call_node_enter, :on_symbol_node_enter, :on_string_node_enter)
@@ -121,7 +121,9 @@ def handle_association(node)
 
       #: (Prism::CallNode node) -> void
       def handle_route(node)
-        result = @client.route_location(T.must(node.message))
+        result = @client.route_location(
+          node.message, #: as !nil
+        )
         return unless result
 
         @response_builder << Support::LocationBuilder.line_location_from_s(result.fetch(:location))

lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -15,7 +15,7 @@ class DocumentSymbol
       #: (ResponseBuilders::DocumentSymbol response_builder, Prism::Dispatcher dispatcher) -> void
       def initialize(response_builder, dispatcher)
         @response_builder = response_builder
-        @namespace_stack = T.let([], T::Array[String])
+        @namespace_stack = [] #: Array[String]
 
         dispatcher.register(
           self,
@@ -45,14 +45,16 @@ def on_call_node_enter(node)
         return if receiver && !receiver.is_a?(Prism::SelfNode)
 
         message = node.message
+        return unless message
+
         case message
         when *Support::Callbacks::ALL, "validate"
-          handle_all_arg_types(node, T.must(message))
+          handle_all_arg_types(node, message)
         when "validates", "validates!", "validates_each", "belongs_to", "has_one", "has_many",
           "has_and_belongs_to_many", "attr_readonly", "scope"
-          handle_symbol_and_string_arg_types(node, T.must(message))
+          handle_symbol_and_string_arg_types(node, message)
         when "validates_with"
-          handle_class_arg_types(node, T.must(message))
+          handle_class_arg_types(node, message)
         end
       end
 
@@ -113,7 +115,9 @@ def handle_all_arg_types(node, message)
             append_document_symbol(
               name: "#{message} :#{name}",
               range: range_from_location(argument.location),
-              selection_range: range_from_location(T.must(argument.value_loc)),
+              selection_range: range_from_location(
+                argument.value_loc, #: as !nil
+              ),
             )
           when Prism::StringNode
             name = argument.content
@@ -172,7 +176,9 @@ def handle_symbol_and_string_arg_types(node, message)
             append_document_symbol(
               name: "#{message} :#{name}",
               range: range_from_location(argument.location),
-              selection_range: range_from_location(T.must(argument.value_loc)),
+              selection_range: range_from_location(
+                argument.value_loc, #: as !nil
+              ),
             )
           when Prism::StringNode
             name = argument.content

lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -21,8 +21,8 @@ class Hover
       def initialize(client, response_builder, node_context, global_state, dispatcher)
         @client = client
         @response_builder = response_builder
-        @nesting = T.let(node_context.nesting, T::Array[String])
-        @index = T.let(global_state.index, RubyIndexer::Index)
+        @nesting = node_context.nesting #: Array[String]
+        @index = global_state.index #: RubyIndexer::Index
         dispatcher.register(self, :on_constant_path_node_enter, :on_constant_read_node_enter)
       end
 

lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb

@@ -15,7 +15,7 @@ def resolve_test_commands(items)
           full_files = []
 
           until queue.empty?
-            item = T.must(queue.shift)
+            item = queue.shift #: as !nil
             tags = Set.new(item[:tags])
             next unless tags.include?("framework:rails")
 

lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -49,8 +49,8 @@ class EmptyMessageError < MessageError; end
 
       #: (Thread::Queue outgoing_queue, RubyLsp::GlobalState global_state) -> void
       def initialize(outgoing_queue, global_state)
-        @outgoing_queue = T.let(outgoing_queue, Thread::Queue)
-        @mutex = T.let(Mutex.new, Mutex)
+        @outgoing_queue = outgoing_queue #: Thread::Queue
+        @mutex = Mutex.new #: Mutex
         # Spring needs a Process session ID. It uses this ID to "attach" itself to the parent process, so that when the
         # parent ends, the spring process ends as well. If this is not set, Spring will throw an error while trying to
         # set its own session ID
@@ -78,21 +78,21 @@ def initialize(outgoing_queue, global_state)
           )
         end
 
-        @stdin = T.let(stdin, IO)
-        @stdout = T.let(stdout, IO)
-        @stderr = T.let(stderr, IO)
+        @stdin = stdin #: IO
+        @stdout = stdout #: IO
+        @stderr = stderr #: IO
         @stdin.sync = true
         @stdout.sync = true
         @stderr.sync = true
-        @wait_thread = T.let(wait_thread, Process::Waiter)
+        @wait_thread = wait_thread #: Process::Waiter
 
         # We set binmode for Windows compatibility
         @stdin.binmode
         @stdout.binmode
         @stderr.binmode
 
-        initialize_response = T.must(read_response)
-        @rails_root = T.let(initialize_response[:root], String)
+        initialize_response = read_response #: as !nil
+        @rails_root = initialize_response[:root] #: String
         log_message("Finished booting Ruby LSP Rails server")
 
         unless ENV["RAILS_ENV"] == "test"
@@ -106,20 +106,17 @@ def initialize(outgoing_queue, global_state)
 
         # Responsible for transmitting notifications coming from the server to the outgoing queue, so that we can do
         # things such as showing progress notifications initiated by the server
-        @notifier_thread = T.let(
-          Thread.new do
-            until @stderr.closed?
-              notification = read_notification
-
-              unless @outgoing_queue.closed? || !notification
-                @outgoing_queue << notification
-              end
+        @notifier_thread = Thread.new do
+          until @stderr.closed?
+            notification = read_notification
+
+            unless @outgoing_queue.closed? || !notification
+              @outgoing_queue << notification
             end
-          rescue IOError
-            # The server was shutdown and stderr is already closed
-          end,
-          Thread,
-        )
+          end
+        rescue IOError
+          # The server was shutdown and stderr is already closed
+        end #: Thread
       rescue StandardError
         raise InitializationError, @stderr.read
       end
@@ -298,9 +295,9 @@ def read_response
           raise EmptyMessageError unless content_length
 
           @stdout.read(content_length)
-        end
+        end #: as !nil
 
-        response = JSON.parse(T.must(raw_response), symbolize_names: true)
+        response = JSON.parse(raw_response, symbolize_names: true)
 
         if response[:error]
           log_message(
@@ -319,7 +316,10 @@ def read_response
       #: -> void
       def force_kill
         # Windows does not support the `TERM` signal, so we're forced to use `KILL` here
-        Process.kill(T.must(Signal.list["KILL"]), @wait_thread.pid)
+        Process.kill(
+          Signal.list["KILL"], #: as !nil
+          @wait_thread.pid,
+        )
       end
 
       #: (::String message, ?type: ::Integer) -> void