tapioca 0.17.3 → 0.17.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e446027e2b7e92d0a593cab8758e2c4ea86914b4e92af06c5ef4f9d102740a4e
-  data.tar.gz: 688fb813c21f03b6d9536829d712b064fa8296ff6ccce973d4655c6f576fe37f
+  metadata.gz: 302108d7d02504d88d18e3b0ae4832e2fd6c891e83f6428d69d5c4f6773a3a73
+  data.tar.gz: 646642051b0b9d8736ad30e45d0b1bcfbe82f92b980f0909c45dc7f2337e0ce1
 SHA512:
-  metadata.gz: '08aaa410199a74707132460863b0cdc7396f5c62c12e8cfd700b6e9bf66aae2df2e77b5bc4818626380c7cfbfa61adeccca1deba7c66547a91e8047b4e65ccb3'
-  data.tar.gz: 59e4b41df9b651a33eb66968d11813a563e29e9a0e43ab73566f33d3de1305be5be20386d1227f95596ebf9c67a4bef82d71dc327952a9e166f7674ff0212218
+  metadata.gz: c6a75f400e82b9f311f0f53713a843a94a3e444a6a52b09d83abd818226a058ec78f02e43b193e864fc90f895ecad0425e7b9d160aaa7c4681b354392a7ad594
+  data.tar.gz: 831256628c364563d69fe8d742f9fe0a973e12275bdbb5498a6af83c664036aa199ec0a94bf9ba527d3165723bf17aa5852e9eb2b993ccc0ed7439ef0f663a68

data/lib/ruby_lsp/tapioca/addon.rb

@@ -1,7 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
-RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.25")
+RubyLsp::Addon.depend_on_ruby_lsp!(">= 0.23.10", "< 0.26")
 
 begin
   # The Tapioca add-on depends on the Rails add-on to add a runtime component to the runtime server. We can allow the

data/lib/ruby_lsp/tapioca/server_addon.rb

@@ -19,13 +19,15 @@ module RubyLsp
         when "load_compilers_and_extensions"
           # Load DSL extensions and compilers ahead of time, so that we don't have to pay the price of invoking
           # `Gem.find_files` on every execution, which is quite expensive
-          @loader = ::Tapioca::Loaders::Dsl.new(
-            tapioca_path: ::Tapioca::TAPIOCA_DIR,
-            eager_load: false,
-            app_root: params[:workspace_path],
-            halt_upon_load_error: false,
-          )
-          @loader.load_dsl_extensions_and_compilers
+          with_notification_wrapper("load_compilers_and_extensions", "Loading DSL compilers") do
+            @loader = ::Tapioca::Loaders::Dsl.new(
+              tapioca_path: ::Tapioca::TAPIOCA_DIR,
+              eager_load: false,
+              app_root: params[:workspace_path],
+              halt_upon_load_error: false,
+            )
+            @loader.load_dsl_extensions_and_compilers
+          end
         when "dsl"
           fork do
             with_notification_wrapper("dsl", "Generating DSL RBIs") do

data/lib/tapioca/bundler_ext/auto_require_hook.rb

@@ -6,12 +6,9 @@ module Tapioca
     # This is a module that gets prepended to `Bundler::Dependency` and
     # makes sure even gems marked as `require: false` are required during
     # `Bundler.require`.
+    # @requires_ancestor: ::Bundler::Dependency
     module AutoRequireHook
       extend T::Sig
-      extend T::Helpers
-
-      requires_ancestor { ::Bundler::Dependency }
-
       @exclude = [] #: Array[String]
       @enabled = false #: bool
 

data/lib/tapioca/cli.rb

@@ -382,12 +382,12 @@ module Tapioca
         # Indicates that we are running from the LSP, set using the `addon_mode!` method
         attr_reader :addon_mode
 
-        sig { void }
+        #: -> void
         def addon_mode!
           @addon_mode = true
         end
 
-        sig { returns(T::Boolean) }
+        #: -> bool
         def exit_on_failure?
           !@addon_mode
         end

data/lib/tapioca/commands/abstract_dsl.rb

@@ -3,12 +3,11 @@
 
 module Tapioca
   module Commands
+    # @abstract
     class AbstractDsl < CommandWithoutTracker
       include SorbetHelper
       include RBIFilesHelper
 
-      abstract!
-
       #: (requested_constants: Array[String], requested_paths: Array[Pathname], outpath: Pathname, only: Array[String], exclude: Array[String], file_header: bool, tapioca_path: String, ?skip_constant: Array[String], ?quiet: bool, ?verbose: bool, ?number_of_workers: Integer?, ?auto_strictness: bool, ?gem_dir: String, ?rbi_formatter: RBIFormatter, ?app_root: String, ?halt_upon_load_error: bool, ?compiler_options: Hash[String, untyped], ?lsp_addon: bool) -> void
       def initialize(
         requested_constants:,

data/lib/tapioca/commands/abstract_gem.rb

@@ -3,12 +3,11 @@
 
 module Tapioca
   module Commands
+    # @abstract
     class AbstractGem < Command
       include SorbetHelper
       include RBIFilesHelper
 
-      abstract!
-
       #: (gem_names: Array[String], exclude: Array[String], include_dependencies: bool, prerequire: String?, postrequire: String, typed_overrides: Hash[String, String], outpath: Pathname, file_header: bool, include_doc: bool, include_loc: bool, include_exported_rbis: bool, ?number_of_workers: Integer?, ?auto_strictness: bool, ?dsl_dir: String, ?rbi_formatter: RBIFormatter, ?halt_upon_load_error: bool, ?lsp_addon: bool?) -> void
       def initialize(
         gem_names:,

data/lib/tapioca/commands/annotations.rb

@@ -125,7 +125,7 @@ module Tapioca
         fetched_gems.keys.map(&:name).sort
       end
 
-      sig { params(repo_uris: T::Array[String], gem_info: GemInfo).returns(T::Boolean) }
+      #: (Array[String] repo_uris, GemInfo gem_info) -> bool
       def fetch_annotation(repo_uris, gem_info)
         gem_name = gem_info.name
         gem_version = gem_info.version

data/lib/tapioca/commands/command.rb

@@ -3,10 +3,9 @@
 
 module Tapioca
   module Commands
+    # @abstract
     class Command
       extend T::Sig
-      extend T::Helpers
-
       class FileWriter < Thor
         include Thor::Actions
       end
@@ -14,8 +13,6 @@ module Tapioca
       include Thor::Base
       include CliHelper
 
-      abstract!
-
       #: -> void
       def initialize
         @file_writer = FileWriter.new #: Thor::Actions
@@ -31,8 +28,9 @@ module Tapioca
 
       private
 
-      sig { abstract.void }
-      def execute; end
+      # @abstract
+      #: -> void
+      def execute = raise NotImplementedError, "Abstract method called"
 
       #: (Symbol command, *String args) -> String
       def default_command(command, *args)

data/lib/tapioca/commands/command_without_tracker.rb

@@ -3,11 +3,8 @@
 
 module Tapioca
   module Commands
+    # @abstract
     class CommandWithoutTracker < Command
-      extend T::Helpers
-
-      abstract!
-
       #: -> void
       def initialize
         Tapioca::Runtime::Trackers.disable_all!

data/lib/tapioca/dsl/compiler.rb

@@ -3,19 +3,15 @@
 
 module Tapioca
   module Dsl
+    # @abstract
+    #: [ConstantType < Module]
     class Compiler
       extend T::Sig
-      extend T::Helpers
-      extend T::Generic
 
       include RBIHelper
       include Runtime::Reflection
       extend Runtime::Reflection
 
-      ConstantType = type_member { { upper: Module } }
-
-      abstract!
-
       #: ConstantType
       attr_reader :constant
 
@@ -35,8 +31,9 @@ module Tapioca
           processable_constants.include?(constant)
         end
 
-        sig { abstract.returns(T::Enumerable[Module]) }
-        def gather_constants; end
+        # @abstract
+        #: -> T::Enumerable[Module]
+        def gather_constants = raise NotImplementedError, "Abstract method called"
 
         #: -> Set[Module]
         def processable_constants
@@ -100,8 +97,9 @@ module Tapioca
         @pipeline.compiler_enabled?(compiler_name)
       end
 
-      sig { abstract.void }
-      def decorate; end
+      # @abstract
+      #: -> void
+      def decorate = raise NotImplementedError, "Abstract method called"
 
       # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
       #: (String error) -> void

data/lib/tapioca/dsl/compilers/aasm.rb

@@ -32,6 +32,7 @@ module Tapioca
       #   sleeping?, running?, cleaning?
       #   run, run!, run_without_validation!, may_run?
       #
+      #: [ConstantType = (Class[::AASM] & ::AASM::ClassMethods)]
       class AASM < Compiler
         extend T::Sig
 
@@ -68,8 +69,6 @@ module Tapioca
           "success",
         ].freeze #: Array[String]
 
-        ConstantType = type_member { { fixed: T.all(T::Class[::AASM], ::AASM::ClassMethods) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/action_controller_helpers.rb

@@ -61,11 +61,10 @@ module Tapioca
       #   def helpers; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActionController::Base)]
       class ActionControllerHelpers < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActionController::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/action_mailer.rb

@@ -29,11 +29,10 @@ module Tapioca
       #   def self.notify_customer(customer_id); end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActionMailer::Base)]
       class ActionMailer < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActionMailer::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/action_text.rb

@@ -43,11 +43,10 @@ module Tapioca
       #  def title?; end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActionText < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_job.rb

@@ -38,11 +38,10 @@ module Tapioca
       #   def self.perform_now(user); end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveJob::Base)]
       class ActiveJob < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveJob::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_model_attributes.rb

@@ -34,13 +34,10 @@ module Tapioca
       #   def name=(name); end
       # end
       # ~~~
+      #: [ConstantType = (Class[::ActiveModel::Attributes] & ::ActiveModel::Attributes::ClassMethods)]
       class ActiveModelAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          { fixed: T.all(T::Class[::ActiveModel::Attributes], ::ActiveModel::Attributes::ClassMethods) }
-        end
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_model_secure_password.rb

@@ -53,13 +53,10 @@ module Tapioca
       #   def token_confirmation=(unencrypted_password); end
       # end
       # ~~~
+      #: [ConstantType = (Class[::ActiveModel::SecurePassword] & ::ActiveModel::SecurePassword::ClassMethods)]
       class ActiveModelSecurePassword < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          { fixed: T.all(T::Class[::ActiveModel::SecurePassword], ::ActiveModel::SecurePassword::ClassMethods) }
-        end
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_model_validations_confirmation.rb

@@ -40,19 +40,10 @@ module Tapioca
       #   def password_confirmation=(password_confirmation); end
       # end
       # ~~~
+      #: [ConstantType = (Class[ActiveModel::Validations] & ActiveModel::Validations::HelperMethods & ActiveModel::Validations::ClassMethods)]
       class ActiveModelValidationsConfirmation < Compiler
         extend T::Sig
 
-        ConstantType = type_member do
-          {
-            fixed: T.all(
-              T::Class[ActiveModel::Validations],
-              ActiveModel::Validations::HelperMethods,
-              ActiveModel::Validations::ClassMethods,
-            ),
-          }
-        end
-
         class << self
           # @override
           #: -> T::Enumerable[Module]

data/lib/tapioca/dsl/compilers/active_record_associations.rb

@@ -101,6 +101,7 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(ActiveRecord::Base)]
       class ActiveRecordAssociations < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
@@ -121,8 +122,6 @@ module Tapioca
           end
         end
 
-        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_columns.rb

@@ -120,12 +120,11 @@ module Tapioca
       #     sig { returns(T.untyped) }
       #     def title; end
       # ~~~
+      #: [ConstantType = singleton(ActiveRecord::Base)]
       class ActiveRecordColumns < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.class_of(ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_delegated_types.rb

@@ -63,12 +63,11 @@ module Tapioca
       # end
       #
       # ~~~
+      #: [ConstantType = (singleton(ActiveRecord::Base) & Extensions::ActiveRecord)]
       class ActiveRecordDelegatedTypes < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_enum.rb

@@ -49,11 +49,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordEnum < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_fixtures.rb

@@ -33,10 +33,10 @@ module Tapioca
       #   def posts(fixture_name = nil, *other_fixtures); end
       # end
       # ~~~
+      #: [ConstantType = singleton(ActiveSupport::TestCase)]
       class ActiveRecordFixtures < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(ActiveSupport::TestCase) } }
         MISSING = Object.new
 
         # @override

data/lib/tapioca/dsl/compilers/active_record_relations.rb

@@ -148,13 +148,12 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordRelations < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
         include SorbetHelper
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # From ActiveRecord::ConnectionAdapter::Quoting#quote, minus nil
         ID_TYPES = [
           "String",
@@ -217,6 +216,17 @@ module Tapioca
           []
         end #: Array[Symbol]
         BATCHES_METHODS = ActiveRecord::Batches.instance_methods(false) #: Array[Symbol]
+        BATCHES_METHODS_PARAMETERS = {
+          start: ["T.untyped", "nil"],
+          finish: ["T.untyped", "nil"],
+          load: ["T.untyped", "false"],
+          batch_size: ["Integer", "1000"],
+          of: ["Integer", "1000"],
+          error_on_ignore: ["T.untyped", "nil"],
+          order: ["Symbol", ":asc"],
+          cursor: ["T.untyped", "primary_key"],
+          use_ranges: ["T.untyped", "nil"],
+        } #: Hash[Symbol, [String, String]]
         CALCULATION_METHODS = ActiveRecord::Calculations.instance_methods(false) #: Array[Symbol]
         ENUMERABLE_QUERY_METHODS = [:any?, :many?, :none?, :one?] #: Array[Symbol]
         FIND_OR_CREATE_METHODS = [
@@ -855,102 +865,31 @@ module Tapioca
           end
 
           BATCHES_METHODS.each do |method_name|
-            case method_name
-            when :find_each
-              order = ActiveRecord::Batches.instance_method(:find_each).parameters.include?([:key, :order])
-
-              common_relation_methods_module.create_method("find_each") do |method|
-                method.add_kw_opt_param("start", "nil")
-                method.add_kw_opt_param("finish", "nil")
-                method.add_kw_opt_param("batch_size", "1000")
-                method.add_kw_opt_param("error_on_ignore", "nil")
-                method.add_kw_opt_param("order", ":asc") if order
-                method.add_block_param("block")
+            block_param, return_type, parameters = batch_method_configs(method_name)
+            next if block_param.nil? || return_type.nil? || parameters.nil?
 
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("block", "T.proc.params(object: #{constant_name}).void")
-                  sig.return_type = "void"
-                end
+            common_relation_methods_module.create_method(method_name.to_s) do |method|
+              parameters.each do |name, (style, _type, default)|
+                # The style is always "key", but this is a safeguard to prevent confusing errors in the future.
+                raise "Unexpected style #{style} for #{name}" unless style == :key
 
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.return_type = "T::Enumerator[#{constant_name}]"
-                end
+                method.add_kw_opt_param(name, T.must(default))
               end
-            when :find_in_batches
-              order = ActiveRecord::Batches.instance_method(:find_in_batches).parameters.include?([:key, :order])
-              common_relation_methods_module.create_method("find_in_batches") do |method|
-                method.add_kw_opt_param("start", "nil")
-                method.add_kw_opt_param("finish", "nil")
-                method.add_kw_opt_param("batch_size", "1000")
-                method.add_kw_opt_param("error_on_ignore", "nil")
-                method.add_kw_opt_param("order", ":asc") if order
-                method.add_block_param("block")
-
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("block", "T.proc.params(object: T::Array[#{constant_name}]).void")
-                  sig.return_type = "void"
-                end
+              method.add_block_param("block")
 
-                method.add_sig do |sig|
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("batch_size", "Integer")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.return_type = "T::Enumerator[T::Enumerator[#{constant_name}]]"
+              method.add_sig do |sig|
+                parameters.each do |name, (_style, type, _default)|
+                  sig.add_param(name, type)
                 end
+                sig.add_param("block", "T.proc.params(object: #{block_param}).void")
+                sig.return_type = "void"
               end
-            when :in_batches
-              order = ActiveRecord::Batches.instance_method(:in_batches).parameters.include?([:key, :order])
-              use_ranges = ActiveRecord::Batches.instance_method(:in_batches).parameters.include?([:key, :use_ranges])
-
-              common_relation_methods_module.create_method("in_batches") do |method|
-                method.add_kw_opt_param("of", "1000")
-                method.add_kw_opt_param("start", "nil")
-                method.add_kw_opt_param("finish", "nil")
-                method.add_kw_opt_param("load", "false")
-                method.add_kw_opt_param("error_on_ignore", "nil")
-                method.add_kw_opt_param("order", ":asc") if order
-                method.add_kw_opt_param("use_ranges", "nil") if use_ranges
-                method.add_block_param("block")
-
-                method.add_sig do |sig|
-                  sig.add_param("of", "Integer")
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("load", "T.untyped")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("use_ranges", "T.untyped") if use_ranges
-                  sig.add_param("block", "T.proc.params(object: #{RelationClassName}).void")
-                  sig.return_type = "void"
-                end
 
-                method.add_sig do |sig|
-                  sig.add_param("of", "Integer")
-                  sig.add_param("start", "T.untyped")
-                  sig.add_param("finish", "T.untyped")
-                  sig.add_param("load", "T.untyped")
-                  sig.add_param("error_on_ignore", "T.untyped")
-                  sig.add_param("order", "Symbol") if order
-                  sig.add_param("use_ranges", "T.untyped") if use_ranges
-                  sig.return_type = "::ActiveRecord::Batches::BatchEnumerator"
+              method.add_sig do |sig|
+                parameters.each do |name, (_style, type, _default)|
+                  sig.add_param(name, type)
                 end
+                sig.return_type = return_type
               end
             end
           end
@@ -1029,6 +968,31 @@ module Tapioca
           end
         end
 
+        #: (Symbol) -> [String, String, Hash[String, [Symbol, String, String?]]]?
+        def batch_method_configs(method_name)
+          block_param, return_type = case method_name
+          when :find_each
+            [constant_name, "T::Enumerator[#{constant_name}]"]
+          when :find_in_batches
+            ["T::Array[#{constant_name}]", "T::Enumerator[T::Enumerator[#{constant_name}]]"]
+          when :in_batches
+            [RelationClassName, "::ActiveRecord::Batches::BatchEnumerator"]
+          else
+            return
+          end
+
+          parameters = {}
+
+          ActiveRecord::Batches.instance_method(method_name).parameters.each do |style, name|
+            type, default = BATCHES_METHODS_PARAMETERS[name]
+            next if type.nil?
+
+            parameters[name.to_s] = [style, type, default]
+          end
+
+          [block_param, return_type, parameters]
+        end
+
         #: ((Symbol | String) name, ?parameters: Array[RBI::TypedParam], ?return_type: String?) -> void
         def create_common_method(name, parameters: [], return_type: nil)
           common_relation_methods_module.create_method(

data/lib/tapioca/dsl/compilers/active_record_scope.rb

@@ -38,12 +38,11 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordScope < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_secure_token.rb

@@ -32,12 +32,11 @@ module Tapioca
       #   def regenerate_auth_token; end
       # end
       # ~~~
+      #: [ConstantType = (singleton(ActiveRecord::Base) & Extensions::ActiveRecord)]
       class ActiveRecordSecureToken < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_store.rb

@@ -78,12 +78,11 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = (singleton(ActiveRecord::Base) & Extensions::ActiveRecord)]
       class ActiveRecordStore < Compiler
         extend T::Sig
         include Helpers::ActiveRecordConstantsHelper
 
-        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
-
         # @override
         #: -> void
         def decorate

data/lib/tapioca/dsl/compilers/active_record_typed_store.rb

@@ -81,11 +81,10 @@ module Tapioca
       #   end
       # end
       # ~~~
+      #: [ConstantType = singleton(::ActiveRecord::Base)]
       class ActiveRecordTypedStore < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.class_of(::ActiveRecord::Base) } }
-
         # @override
         #: -> void
         def decorate