ruby-lsp-rails 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea71850cee42d73b31e37c68aa3438a7d59c4c610fef1e2e20a157ff7c7bd92d
-  data.tar.gz: 5d4506c255005cc442fbe95fc73bfe58220a70155313b4451b8a3e549feef9de
+  metadata.gz: 76155fcaf046652d4e13655bf8f1d38764a0a755cd4e090a70a7e551e77dc598
+  data.tar.gz: d417e7a57d97dbd0a7b1b2aa2ec999793ef6a8fb3ada39a0c1ad06688af8fd3b
 SHA512:
-  metadata.gz: e8538d6e4330168cc5d480ca157cb0c57e178ff3b24429f1a456986e3f91f471a830b3d6ab04b943dd5d18f4d9116ff25ccf94da91db28e8c9c4ad850a488532
-  data.tar.gz: d527c41fcffc45935bab4a5b6332d940c07fdcbaaec189a223bbba5db46459d2f5fb033a3a4809f7ffc74aa1bf1cdcb0ed228cc6f244db4b25ff2ea57aa57421
+  metadata.gz: 5f53d2aebe48cb0ce755541d4af87e564d2ca5dcdd70f411390c4d685890f6d398da400f223a77678c56e915b6a34ea6330b4495a02f407967040c07d9a5a164
+  data.tar.gz: 063117bc235a4bf99f148d65c8170601a35b58b7d95ad8098114ccd213c930f0d9a8ea12f51b12022c7ad6284672209ae0eafbd475f079c325ff8bc236c08688

data/Rakefile

@@ -10,19 +10,10 @@ load "rails/tasks/statistics.rake"
 require "bundler/gem_tasks"
 require "rake/testtask"
 
-# Since `server.rb` runs within the host Rails application, we want to ensure
-# we don't accidentally depend on sorbet-runtime. `server_test` intentionally doesn't use `test_helper`.
-# We run `server_test` in a seperate Rake task.
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"] - ["test/ruby_lsp_rails/server_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"]
 end
 
-Rake::TestTask.new(:server_test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = ["test/ruby_lsp_rails/server_test.rb"]
-end
-
-task default: [:"db:setup", :test, :server_test]
+task default: :test

data/lib/ruby_lsp/ruby_lsp_rails/addon.rb

@@ -28,24 +28,25 @@ module RubyLsp
 
         # 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

data/lib/ruby_lsp/ruby_lsp_rails/code_lens.rb

@@ -80,10 +80,10 @@ module RubyLsp
         @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 @@ module RubyLsp
 
       #: (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 @@ module RubyLsp
 
       #: -> 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

data/lib/ruby_lsp/ruby_lsp_rails/completion.rb

@@ -37,7 +37,7 @@ module RubyLsp
         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)

data/lib/ruby_lsp/ruby_lsp_rails/definition.rb

@@ -35,7 +35,7 @@ module RubyLsp
         @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 @@ module RubyLsp
 
       #: (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))

data/lib/ruby_lsp/ruby_lsp_rails/document_symbol.rb

@@ -15,7 +15,7 @@ module RubyLsp
       #: (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 @@ module RubyLsp
         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 @@ module RubyLsp
             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 @@ module RubyLsp
             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

data/lib/ruby_lsp/ruby_lsp_rails/hover.rb

@@ -21,8 +21,8 @@ module RubyLsp
       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
 

data/lib/ruby_lsp/ruby_lsp_rails/rails_test_style.rb

@@ -15,7 +15,7 @@ module RubyLsp
           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")
 
@@ -88,7 +88,7 @@ module RubyLsp
         first_arg = arguments&.first
         return unless first_arg.is_a?(Prism::StringNode)
 
-        test_name = first_arg.content
+        test_name = first_arg.unescaped
         test_name = "<empty test name>" if test_name.empty?
 
         # Rails' `test "foo bar"` helper defines a method `def test_foo_bar`. We normalize test names

data/lib/ruby_lsp/ruby_lsp_rails/runner_client.rb

@@ -49,8 +49,8 @@ module RubyLsp
 
       #: (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 @@ module RubyLsp
           )
         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 @@ module RubyLsp
 
         # 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 @@ module RubyLsp
           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 @@ module RubyLsp
       #: -> 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

data/lib/ruby_lsp/ruby_lsp_rails/server.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "json"
@@ -7,14 +7,17 @@ require "delegate"
 
 module RubyLsp
   module Rails
+    # @requires_ancestor: ServerComponent
     module Common
       class Progress
+        #: (IO | StringIO, String, bool) -> void
         def initialize(stderr, id, supports_progress)
           @stderr = stderr
           @id = id
           @supports_progress = supports_progress
         end
 
+        #: (percentage: Integer?, message: String?) -> void
         def report(percentage: nil, message: nil)
           return unless @supports_progress
           return unless percentage || message
@@ -37,23 +40,27 @@ module RubyLsp
 
       # Log a message to the editor's output panel. The type is the number of the message type, which can be found in
       # the specification https://microsoft.github.io/language-server-protocol/specification/#messageType
+      #: (String, type: Integer) -> void
       def log_message(message, type: 4)
         send_notification({ method: "window/logMessage", params: { type: type, message: message } })
       end
 
       # Sends an error result to a request, if the request failed. DO NOT INVOKE THIS METHOD FOR NOTIFICATIONS! Use
       # `log_message` instead, otherwise the client/server communication will go out of sync
+      #: (String) -> void
       def send_error_response(message)
         send_message({ error: message })
       end
 
       # Sends a result back to the client
+      #: (Hash[Symbol | String, untyped]?) -> void
       def send_result(result)
         send_message({ result: result })
       end
 
       # Handle possible errors for a request. This should only be used for requests, which means messages that return a
       # response back to the client. Errors are returned as an error object back to the client
+      #: (String) { () -> void } -> void
       def with_request_error_handling(request_name, &block)
         block.call
       rescue ActiveRecord::ConnectionNotEstablished
@@ -67,6 +74,7 @@ module RubyLsp
 
       # Handle possible errors for a notification. This should only be used for notifications, which means messages that
       # do not return a response back to the client. Errors are logged to the editor's output panel
+      #: (String) { () -> void } -> void
       def with_notification_error_handling(notification_name, &block)
         block.call
       rescue ActiveRecord::ConnectionNotEstablished
@@ -78,8 +86,9 @@ module RubyLsp
         log_message("Request #{notification_name} failed:\n#{e.full_message(highlight: false)}")
       end
 
+      #: (String, String, percentage: Integer?, message: String?) -> void
       def begin_progress(id, title, percentage: nil, message: nil)
-        return unless @capabilities[:supports_progress]
+        return unless capabilities[:supports_progress]
 
         # This is actually a request, but it is sent asynchronously and we do not return the response back to the
         # server, so we consider it a notification from the perspective of the client/runtime server dynamic
@@ -103,8 +112,9 @@ module RubyLsp
         })
       end
 
+      #: (String, percentage: Integer?, message: String?) -> void
       def report_progress(id, percentage: nil, message: nil)
-        return unless @capabilities[:supports_progress]
+        return unless capabilities[:supports_progress]
 
         send_notification({
           method: "$/progress",
@@ -119,8 +129,9 @@ module RubyLsp
         })
       end
 
+      #: (String) -> void
       def end_progress(id)
-        return unless @capabilities[:supports_progress]
+        return unless capabilities[:supports_progress]
 
         send_notification({
           method: "$/progress",
@@ -131,9 +142,10 @@ module RubyLsp
         })
       end
 
+      #: (String, String, percentage: Integer?, message: String?) { (Progress) -> void } -> void
       def with_progress(id, title, percentage: nil, message: nil, &block)
-        progress_block = Progress.new(@stderr, id, @capabilities[:supports_progress])
-        return block.call(progress_block) unless @capabilities[:supports_progress]
+        progress_block = Progress.new(stderr, id, capabilities[:supports_progress])
+        return block.call(progress_block) unless capabilities[:supports_progress]
 
         begin_progress(id, title, percentage: percentage, message: message)
         block.call(progress_block)
@@ -143,86 +155,113 @@ module RubyLsp
       private
 
       # Write a response message back to the client
+      #: (Hash[String | Symbol, untyped]) -> void
       def send_message(message)
         json_message = message.to_json
-        @stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+        stdout.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
 
       # Write a notification to the client to be transmitted to the editor
+      #: (Hash[String | Symbol, untyped]) -> void
       def send_notification(message)
         json_message = message.to_json
-        @stderr.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+        stderr.write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
     end
 
-    class ServerAddon
+    class ServerComponent
+      #: IO | StringIO
+      attr_reader :stdout
+
+      #: IO | StringIO
+      attr_reader :stderr
+
+      #: Hash[Symbol | String, untyped]
+      attr_reader :capabilities
+
+      #: (IO | StringIO, IO | StringIO, Hash[Symbol | String, untyped]) -> void
+      def initialize(stdout, stderr, capabilities)
+        @stdout = stdout
+        @stderr = stderr
+        @capabilities = capabilities
+      end
+    end
+
+    class ServerAddon < ServerComponent
       include Common
 
-      @server_addon_classes = []
-      @server_addons = {}
+      @server_addon_classes = [] #: Array[singleton(ServerAddon)]
+      @server_addons = {} #: Hash[String, ServerAddon]
 
       class << self
         # We keep track of runtime server add-ons the same way we track other add-ons, by storing classes that inherit
         # from the base one
+        #: (singleton(ServerAddon)) -> void
         def inherited(child)
           @server_addon_classes << child
           super
         end
 
         # Delegate `request` with `params` to the server add-on with the given `name`
+        #: (String, String, Hash[Symbol | String, untyped]) -> void
         def delegate(name, request, params)
           @server_addons[name]&.execute(request, params)
         end
 
         # Instantiate all server addons and store them in a hash for easy access after we have discovered the classes
+        #: (IO | StringIO, IO | StringIO, Hash[Symbol | String, untyped]) -> void
         def finalize_registrations!(stdout, stderr, capabilities)
           until @server_addon_classes.empty?
-            addon = @server_addon_classes.shift.new(stdout, stderr, capabilities)
+            addon = @server_addon_classes.shift #: as !nil
+              .new(stdout, stderr, capabilities)
             @server_addons[addon.name] = addon
           end
         end
       end
 
-      def initialize(stdout, stderr, capabilities)
-        @stdout = stdout
-        @stderr = stderr
-        @capabilities = capabilities
-      end
-
+      #: -> String
       def name
         raise NotImplementedError, "Not implemented!"
       end
 
+      #: (String, Hash[String | Symbol, untyped]) -> untyped
       def execute(request, params)
         raise NotImplementedError, "Not implemented!"
       end
     end
 
     class IOWrapper < SimpleDelegator
+      #: (untyped) -> void
       def puts(*args)
         args.each { |arg| log("#{arg}\n") }
       end
 
+      #: (untyped) -> void
       def print(*args)
         args.each { |arg| log(arg.to_s) }
       end
 
       private
 
+      #: (untyped) -> void
       def log(message)
         json_message = { method: "window/logMessage", params: { type: 4, message: message } }.to_json
-        write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
+
+        self #: as untyped # rubocop:disable Style/RedundantSelf
+          .write("Content-Length: #{json_message.bytesize}\r\n\r\n#{json_message}")
       end
     end
 
-    class Server
+    class Server < ServerComponent
       include Common
 
+      #: (IO | StringIO, IO | StringIO, bool, Hash[Symbol | String, untyped]) -> void
       def initialize(stdout: $stdout, stderr: $stderr, override_default_output_device: true, capabilities: {})
         # Grab references to the original pipes so that we can change the default output device further down
-        @stdin = $stdin
-        @stdout = stdout
-        @stderr = stderr
+
+        @stdin = $stdin #: IO
+        super(stdout, stderr, capabilities)
+
         @stdin.sync = true
         @stdout.sync = true
         @stderr.sync = true
@@ -230,31 +269,31 @@ module RubyLsp
         @stdout.binmode
         @stderr.binmode
 
-        # A hash containing the capabilities of the editor that may be relevant for the runtime server
-        @capabilities = capabilities
-
         # # Set the default output device to be $stderr. This means that using `puts` by itself will default to printing
         # # to $stderr and only explicit `$stdout.puts` will go to $stdout. This reduces the chance that output coming
         # # from the Rails app will be accidentally sent to the client
         $> = IOWrapper.new(@stderr) if override_default_output_device
 
-        @running = true
+        @running = true #: bool
+        @database_supports_indexing = nil #: bool?
       end
 
+      #: -> void
       def start
         load_routes
         clear_file_system_resolver_hooks
         send_result({ message: "ok", root: ::Rails.root.to_s })
 
         while @running
-          headers = @stdin.gets("\r\n\r\n")
-          json = @stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i)
+          headers = @stdin.gets("\r\n\r\n") #: as String
+          json = @stdin.read(headers[/Content-Length: (\d+)/i, 1].to_i) #: as String
 
           request = JSON.parse(json, symbolize_names: true)
           execute(request.fetch(:method), request[:params])
         end
       end
 
+      #: (String, Hash[Symbol | String, untyped]) -> void
       def execute(request, params)
         case request
         when "shutdown"
@@ -306,6 +345,7 @@ module RubyLsp
 
       private
 
+      #: (Hash[Symbol | String, untyped]) -> Hash[Symbol | String, untyped]?
       def resolve_route_info(requirements)
         if requirements[:controller]
           requirements[:controller] = requirements.fetch(:controller).underscore.delete_suffix("_controller")
@@ -334,6 +374,7 @@ module RubyLsp
       # We also check that it's enabled.
       if ActionDispatch::Routing::Mapper.respond_to?(:route_source_locations) &&
           ActionDispatch::Routing::Mapper.route_source_locations
+        #: (String) -> Hash[Symbol | String, untyped]?
         def route_location(name)
           # In Rails 8, Rails.application.routes.named_routes is not populated by default
           if ::Rails.application.respond_to?(:reload_routes_unless_loaded)
@@ -352,11 +393,13 @@ module RubyLsp
           { location: ::Rails.root.join(route.source_location).to_s }
         end
       else
+        #: (String) -> Hash[Symbol | String, untyped]?
         def route_location(name)
           nil
         end
       end
 
+      #: (String) -> Hash[Symbol | String, untyped]?
       def resolve_database_info_from_model(model_name)
         const = ActiveSupport::Inflector.safe_constantize(model_name)
         return unless active_record_model?(const)
@@ -375,28 +418,33 @@ module RubyLsp
         info
       end
 
+      #: (Hash[Symbol | String, untyped]) -> Hash[Symbol | String, untyped]?
       def resolve_association_target(params)
         const = ActiveSupport::Inflector.safe_constantize(params[:model_name])
         return unless active_record_model?(const)
 
         association_klass = const.reflect_on_association(params[:association_name].intern).klass
         source_location = Object.const_source_location(association_klass.to_s)
+        return unless source_location
 
-        { location: source_location.first + ":" + source_location.second.to_s }
+        { location: "#{source_location[0]}:#{source_location[1]}" }
       rescue NameError
         nil
       end
 
+      #: (Module?) -> bool
       def active_record_model?(const)
         !!(
           const &&
             defined?(ActiveRecord) &&
             const.is_a?(Class) &&
             ActiveRecord::Base > const && # We do this 'backwards' in case the class overwrites `<`
-          !const.abstract_class?
+          !const #: as singleton(ActiveRecord::Base)
+            .abstract_class?
         )
       end
 
+      #: -> String?
       def pending_migrations_message
         # `check_all_pending!` is only available since Rails 7.1
         return unless defined?(ActiveRecord) && ActiveRecord::Migration.respond_to?(:check_all_pending!)
@@ -407,6 +455,7 @@ module RubyLsp
         e.message
       end
 
+      #: -> Hash[Symbol | String, untyped]
       def run_migrations
         # Running migrations invokes `load` which will repeatedly load the same files. It's not designed to be invoked
         # multiple times within the same process. To avoid any memory bloat, we run migrations in a separate process
@@ -418,6 +467,7 @@ module RubyLsp
         { message: stdout, status: status.exitstatus }
       end
 
+      #: -> void
       def load_routes
         with_notification_error_handling("initial_load_routes") do
           # Load routes if they haven't been loaded yet (see https://github.com/rails/rails/pull/51614).
@@ -430,6 +480,7 @@ module RubyLsp
       # watches files. Since the Rails application is already booted by the time we reach this script, we can't no-op
       # the file watcher implementation. Instead, we clear the hooks to prevent the registered file watchers from being
       # instantiated
+      #: -> void
       def clear_file_system_resolver_hooks
         return unless defined?(::ActionView::PathRegistry)
 
@@ -438,6 +489,7 @@ module RubyLsp
         end
       end
 
+      #: (singleton(ActiveRecord::Base)) -> Array[String]
       def collect_model_foreign_keys(model)
         return [] unless model.connection.respond_to?(:supports_foreign_keys?) &&
           model.connection.supports_foreign_keys?
@@ -447,6 +499,7 @@ module RubyLsp
         end
       end
 
+      #: (singleton(ActiveRecord::Base)) -> Array[Hash[Symbol, untyped]]
       def collect_model_indexes(model)
         return [] unless database_supports_indexing?(model)
 
@@ -459,8 +512,9 @@ module RubyLsp
         end
       end
 
+      #: (singleton(ActiveRecord::Base)) -> bool
       def database_supports_indexing?(model)
-        return @database_supports_indexing if instance_variable_defined?(:@database_supports_indexing)
+        return @database_supports_indexing unless @database_supports_indexing.nil?
 
         model.connection.indexes(model.table_name)
         @database_supports_indexing = true

data/lib/ruby_lsp/ruby_lsp_rails/support/active_support_test_case_helper.rb

@@ -19,7 +19,8 @@ module RubyLsp
           parts = first_argument.parts
 
           if parts.all? { |part| part.is_a?(Prism::StringNode) }
-            T.cast(parts, T::Array[Prism::StringNode]).map(&:content).join
+            parts #: as Array[Prism::StringNode]
+              .map(&:content).join
           end
         when Prism::StringNode
           first_argument.content

data/lib/ruby_lsp/ruby_lsp_rails/support/associations.rb

@@ -5,15 +5,12 @@ module RubyLsp
   module Rails
     module Support
       module Associations
-        ALL = T.let(
-          [
-            "belongs_to",
-            "has_many",
-            "has_one",
-            "has_and_belongs_to_many",
-          ].freeze,
-          T::Array[String],
-        )
+        ALL = [
+          "belongs_to",
+          "has_many",
+          "has_one",
+          "has_and_belongs_to_many",
+        ].freeze
       end
     end
   end

data/lib/ruby_lsp/ruby_lsp_rails/support/callbacks.rb

@@ -5,66 +5,57 @@ module RubyLsp
   module Rails
     module Support
       module Callbacks
-        MODELS = T.let(
-          [
-            "before_validation",
-            "after_validation",
-            "before_save",
-            "around_save",
-            "after_save",
-            "before_create",
-            "around_create",
-            "after_create",
-            "after_commit",
-            "after_create_commit",
-            "after_update_commit",
-            "after_destroy_commit",
-            "after_save_commit",
-            "after_rollback",
-            "before_update",
-            "around_update",
-            "after_update",
-            "before_destroy",
-            "around_destroy",
-            "after_destroy",
-            "after_initialize",
-            "after_find",
-            "after_touch",
-          ].freeze,
-          T::Array[String],
-        )
+        MODELS = [
+          "before_validation",
+          "after_validation",
+          "before_save",
+          "around_save",
+          "after_save",
+          "before_create",
+          "around_create",
+          "after_create",
+          "after_commit",
+          "after_create_commit",
+          "after_update_commit",
+          "after_destroy_commit",
+          "after_save_commit",
+          "after_rollback",
+          "before_update",
+          "around_update",
+          "after_update",
+          "before_destroy",
+          "around_destroy",
+          "after_destroy",
+          "after_initialize",
+          "after_find",
+          "after_touch",
+        ].freeze
 
-        CONTROLLERS = T.let(
-          [
-            "after_action",
-            "append_after_action",
-            "append_around_action",
-            "append_before_action",
-            "around_action",
-            "before_action",
-            "prepend_after_action",
-            "prepend_around_action",
-            "prepend_before_action",
-            "skip_after_action",
-            "skip_around_action",
-            "skip_before_action",
-          ].freeze,
-          T::Array[String],
-        )
+        CONTROLLERS = [
+          "after_action",
+          "append_after_action",
+          "append_around_action",
+          "append_before_action",
+          "around_action",
+          "before_action",
+          "prepend_after_action",
+          "prepend_around_action",
+          "prepend_before_action",
+          "skip_after_action",
+          "skip_around_action",
+          "skip_before_action",
+        ].freeze
 
-        JOBS = T.let(
-          [
-            "after_enqueue",
-            "after_perform",
-            "around_enqueue",
-            "around_perform",
-            "before_enqueue",
-            "before_perform",
-          ].freeze,
-          T::Array[String],
-        )
+        JOBS = [
+          "after_enqueue",
+          "after_perform",
+          "around_enqueue",
+          "around_perform",
+          "before_enqueue",
+          "before_perform",
+        ].freeze
 
-        ALL = T.let((MODELS + CONTROLLERS + JOBS).freeze, T::Array[String])
+        ALL = (MODELS + CONTROLLERS + JOBS).freeze #: Array[String]
       end
     end
   end

data/lib/ruby_lsp_rails/version.rb

@@ -3,6 +3,6 @@
 
 module RubyLsp
   module Rails
-    VERSION = "0.4.1"
+    VERSION = "0.4.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp-rails
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Shopify
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.23.14
+        version: 0.23.16
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.24.0
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.23.14
+        version: 0.23.16
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.24.0