tapioca 0.10.3 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c5b81fee880c497fca1e34c644d6da53e4f155e45f564c95eb886f0f6c30d69
-  data.tar.gz: d0973ab750b577064e5891c0fbd9dd71ddeb82b54d7d8dfcabad4841052e8d6d
+  metadata.gz: 9df4814fb4f17b9f1d53aab7a9b9b23498cfea0330fb48b47d909af119ac6ea0
+  data.tar.gz: 7f2d233a47a7ceb2b4a1f4894c794d65c2cca9c9e1547022630d7b395de0cd47
 SHA512:
-  metadata.gz: 105ab9194d3e62657fedff6d0fd78b187980b5084af80be294690c00a86ac1544b29bd9d86951f50072c895516ce1541251ac2ff05cbb3a2acbbee5d0e103b51
-  data.tar.gz: 612f856fd4b36301dbfee4cdd80615ee4a684447ea077037c5a72e1c7c216be7c465aae13a5b4462a8db9889929765703293d2935036d7ac1e94b8d21d4ee5fb
+  metadata.gz: f65d462c261005c62b31f0864df29b550d5a07551433203f485f8f66c57a8e100fccdb1deb1b7f29e185a1f6e8bf5b4e9f59387a1ba24ea8b4cff168b1b4ca12
+  data.tar.gz: 721c40a48f379eda0e6302ff59b2a3228f0262c5d2b2bac1111016d92ec02597e9d35c28a38a6fcc903a8ac13b0b8c4dddcc7e1d747907390762f47601d19e68

data/exe/tapioca

@@ -3,19 +3,21 @@
 
 require "sorbet-runtime"
 
-begin
-  T::Configuration.default_checked_level = :never
-  # Suppresses call validation errors
-  T::Configuration.call_validation_error_handler = ->(*) {}
-  # Suppresses errors caused by T.cast, T.let, T.must, etc.
-  T::Configuration.inline_type_error_handler = ->(*) {}
-  # Suppresses errors caused by incorrect parameter ordering
-  T::Configuration.sig_validation_error_handler = ->(*) {}
-rescue
-  # Need this rescue so that if another gem has
-  # already set the checked level by the time we
-  # get to it, we don't fail outright.
-  nil
+unless ENV["ENFORCE_TYPECHECKING"] == "1"
+  begin
+    T::Configuration.default_checked_level = :never
+    # Suppresses call validation errors
+    T::Configuration.call_validation_error_handler = ->(*) {}
+    # Suppresses errors caused by T.cast, T.let, T.must, etc.
+    T::Configuration.inline_type_error_handler = ->(*) {}
+    # Suppresses errors caused by incorrect parameter ordering
+    T::Configuration.sig_validation_error_handler = ->(*) {}
+  rescue
+    # Need this rescue so that if another gem has
+    # already set the checked level by the time we
+    # get to it, we don't fail outright.
+    nil
+  end
 end
 
 require_relative "../lib/tapioca/internal"

data/lib/tapioca/cli.rb

@@ -25,9 +25,12 @@ module Tapioca
 
     desc "init", "get project ready for type checking"
     def init
-      invoke(:configure)
-      invoke(:annotations)
-      invoke(:gem)
+      # We need to make sure that trackers stay enabled until the `gem` command is invoked
+      Runtime::Trackers.with_trackers_enabled do
+        invoke(:configure)
+        invoke(:annotations)
+        invoke(:gem)
+      end
       invoke(:todo)
 
       print_init_next_steps
@@ -293,7 +296,9 @@ module Tapioca
     end
 
     desc "annotations", "Pull gem RBI annotations from remote sources"
-    option :sources, type: :array, default: [CENTRAL_REPO_ROOT_URI],
+    option :sources,
+      type: :array,
+      default: [CENTRAL_REPO_ROOT_URI],
       desc: "URIs of the sources to pull gem RBI annotations from"
     option :netrc, type: :boolean, default: true, desc: "Use .netrc to authenticate to private sources"
     option :netrc_file, type: :string, desc: "Path to .netrc file"

data/lib/tapioca/commands/configure.rb

@@ -70,7 +70,7 @@ module Tapioca
           # typed: true
           # frozen_string_literal: true
 
-          # Add your extra requires here (`#{default_command(:require)}` can be used to boostrap this list)
+          # Add your extra requires here (`#{default_command(:require)}` can be used to bootstrap this list)
         CONTENT
       end
 
@@ -92,7 +92,7 @@ module Tapioca
         @installer ||= Bundler::Installer.new(Bundler.root, Bundler.definition)
       end
 
-      sig { returns(Bundler::StubSpecification) }
+      sig { returns(T.any(Bundler::StubSpecification, ::Gem::Specification)) }
       def spec
         @spec ||= Bundler.definition.specs.find { |s| s.name == "tapioca" }
       end

data/lib/tapioca/commands/gem.rb

@@ -156,9 +156,11 @@ module Tapioca
 
         rbi = RBI::File.new(strictness: @typed_overrides[gem.name] || "true")
 
-        @rbi_formatter.write_header!(rbi,
+        @rbi_formatter.write_header!(
+          rbi,
           default_command(:gem, gem.name),
-          reason: "types exported from the `#{gem.name}` gem") if @file_header
+          reason: "types exported from the `#{gem.name}` gem",
+        ) if @file_header
 
         rbi.root = Tapioca::Gem::Pipeline.new(gem, include_doc: @include_doc, include_loc: @include_loc).compile
 

data/lib/tapioca/dsl/compiler.rb

@@ -101,6 +101,9 @@ module Tapioca
         # rest parameter type
         params << signature.rest_type.to_s if signature.has_rest
 
+        # keyrest parameter type
+        params << signature.keyrest_type.to_s if signature.has_keyrest
+
         # special case `.void` in a proc
         unless signature.block_name.nil?
           params << signature.block_type.to_s.gsub("returns(<VOID>)", "void")
@@ -159,10 +162,7 @@ module Tapioca
       def compile_method_return_type_to_rbi(method_def)
         signature = signature_of(method_def)
         return_type = signature.nil? ? "T.untyped" : name_of_type(signature.return_type)
-        return_type = "void" if return_type == "<VOID>"
-        # Map <NOT-TYPED> to `T.untyped`
-        return_type = "T.untyped" if return_type == "<NOT-TYPED>"
-        return_type
+        sanitize_signature_types(return_type)
       end
     end
   end

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

@@ -44,8 +44,17 @@ module Tapioca
         # https://github.com/aasm/aasm/blob/0e03746/lib/aasm/core/event.rb#L21-L29
         EVENT_CALLBACKS =
           T.let(
-            ["after", "after_commit", "after_transaction", "before", "before_transaction", "ensure", "error",
-             "before_success", "success",].freeze,
+            [
+              "after",
+              "after_commit",
+              "after_transaction",
+              "before",
+              "before_transaction",
+              "ensure",
+              "error",
+              "before_success",
+              "success",
+            ].freeze,
             T::Array[String],
           )
 

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

@@ -0,0 +1,163 @@
+# typed: strict
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+require "tapioca/dsl/helpers/active_record_column_type_helper"
+require "tapioca/dsl/helpers/active_record_constants_helper"
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # `Tapioca::Dsl::Compilers::DelegatedTypes` defines RBI files for subclasses of
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This compiler is only responsible for defining the methods that would be created for delegated_types that
+      # are defined in the Active Record model.
+      #
+      # For example, with the following model class:
+      #
+      # ~~~rb
+      # class Entry < ActiveRecord::Base
+      #   delegated_type :entryable, types: %w[ Message Comment ]
+      # end
+      # ~~~
+      #
+      # this compiler will produce the following methods in the RBI file
+      # `entry.rbi`:
+      #
+      # ~~~rbi
+      # # entry.rbi
+      # # typed: true
+      #
+      # class Entry
+      #   include GeneratedDelegatedTypeMethods
+      #
+      #   module GeneratedDelegatedTypeMethods
+      #     sig { params(args: T.untyped).returns(T.any(Message, Comment)) }
+      #     def build_entryable(*args); end
+      #
+      #     sig { returns(Class) }
+      #     def entryable_class; end
+      #
+      #     sig { returns(ActiveSupport::StringInquirer) }
+      #     def entryable_name; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def message?; end
+      #
+      #     sig { returns(T.nilable(Message)) }
+      #     def message; end
+      #
+      #     sig { returns(T.nilable(Integer)) }
+      #     def message_id; end
+      #
+      #     sig { returns(T::Boolean) }
+      #     def comment?; end
+      #
+      #     sig { returns(T.nilable(Comment)) }
+      #     def comment; end
+      #
+      #     sig { returns(T.nilable(Integer)) }
+      #     def comment_id; end
+      #   end
+      # end
+      #
+      # ~~~
+      class ActiveRecordDelegatedTypes < Compiler
+        extend T::Sig
+        include Helpers::ActiveRecordConstantsHelper
+
+        ConstantType = type_member { { fixed: T.all(T.class_of(ActiveRecord::Base), Extensions::ActiveRecord) } }
+
+        sig { override.void }
+        def decorate
+          return if constant.__tapioca_delegated_types.nil?
+
+          root.create_path(constant) do |model|
+            model.create_module(DelegatedTypesModuleName) do |mod|
+              constant.__tapioca_delegated_types.each do |role, data|
+                types = data.fetch(:types)
+                options = data.fetch(:options, {})
+                populate_role_accessors(mod, role, types)
+                populate_type_helpers(mod, role, types, options)
+              end
+            end
+
+            model.create_include(DelegatedTypesModuleName)
+          end
+        end
+
+        class << self
+          extend T::Sig
+
+          sig { override.returns(T::Enumerable[Module]) }
+          def gather_constants
+            descendants_of(::ActiveRecord::Base).reject(&:abstract_class?)
+          end
+        end
+
+        private
+
+        sig { params(mod: RBI::Scope, role: Symbol, types: T::Array[String]).void }
+        def populate_role_accessors(mod, role, types)
+          mod.create_method(
+            "#{role}_name",
+            parameters: [],
+            return_type: "ActiveSupport::StringInquirer",
+          )
+
+          mod.create_method(
+            "#{role}_class",
+            parameters: [],
+            return_type: "Class",
+          )
+
+          mod.create_method(
+            "build_#{role}",
+            parameters: [create_rest_param("args", type: "T.untyped")],
+            return_type: "T.any(#{types.join(", ")})",
+          )
+        end
+
+        sig { params(mod: RBI::Scope, role: Symbol, types: T::Array[String], options: T::Hash[Symbol, T.untyped]).void }
+        def populate_type_helpers(mod, role, types, options)
+          types.each do |type|
+            populate_type_helper(mod, role, type, options)
+          end
+        end
+
+        sig { params(mod: RBI::Scope, role: Symbol, type: String, options: T::Hash[Symbol, T.untyped]).void }
+        def populate_type_helper(mod, role, type, options)
+          singular   = type.tableize.tr("/", "_").singularize
+          query      = "#{singular}?"
+          primary_key = options[:primary_key] || "id"
+          role_id = options[:foreign_key] || "#{role}_id"
+
+          getter_type, _ = Helpers::ActiveRecordColumnTypeHelper.new(constant).type_for(role_id.to_s)
+
+          mod.create_method(
+            query,
+            parameters: [],
+            return_type: "T::Boolean",
+          )
+
+          mod.create_method(
+            singular,
+            parameters: [],
+            return_type: "T.nilable(#{type})",
+          )
+
+          mod.create_method(
+            "#{singular}_#{primary_key}",
+            parameters: [],
+            return_type: as_nilable_type(getter_type),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -72,11 +72,14 @@ module Tapioca
 
         sig { returns(Class) }
         def fixture_loader
-          @fixture_loader ||= T.let(Class.new do
-            T.unsafe(self).include(ActiveRecord::TestFixtures)
-            T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
-            T.unsafe(self).fixtures(:all)
-          end, T.nilable(Class))
+          @fixture_loader ||= T.let(
+            Class.new do
+              T.unsafe(self).include(ActiveRecord::TestFixtures)
+              T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+              T.unsafe(self).fixtures(:all)
+            end,
+            T.nilable(Class),
+          )
         end
 
         sig { returns(T::Array[String]) }

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

@@ -196,27 +196,34 @@ module Tapioca
           T::Array[Symbol],
         )
 
-        QUERY_METHODS = T.let(begin
-          # Grab all Query methods
-          query_methods = ActiveRecord::QueryMethods.instance_methods(false)
-          # Grab all Spawn methods
-          query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
-          # Remove the ones we know are private API
-          query_methods -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
-          # Remove "where" which needs a custom return type for WhereChains
-          query_methods -= [:where]
-          # Remove the methods that ...
-          query_methods
-            .grep_v(/_clause$/) # end with "_clause"
-            .grep_v(/_values?$/) # end with "_value" or "_values"
-            .grep_v(/=$/) # end with "=""
-            .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
-        end, T::Array[Symbol])
+        QUERY_METHODS = T.let(
+          begin
+            # Grab all Query methods
+            query_methods = ActiveRecord::QueryMethods.instance_methods(false)
+            # Grab all Spawn methods
+            query_methods |= ActiveRecord::SpawnMethods.instance_methods(false)
+            # Remove the ones we know are private API
+            query_methods -= [:arel, :build_subquery, :construct_join_dependency, :extensions, :spawn]
+            # Remove "where" which needs a custom return type for WhereChains
+            query_methods -= [:where]
+            # Remove the methods that ...
+            query_methods
+              .grep_v(/_clause$/) # end with "_clause"
+              .grep_v(/_values?$/) # end with "_value" or "_values"
+              .grep_v(/=$/) # end with "=""
+              .grep_v(/(?<!uniq)!$/) # end with "!" except for "uniq!"
+          end,
+          T::Array[Symbol],
+        )
         WHERE_CHAIN_QUERY_METHODS = T.let(
           ActiveRecord::QueryMethods::WhereChain.instance_methods(false),
           T::Array[Symbol],
         )
         FINDER_METHODS = T.let(ActiveRecord::FinderMethods.instance_methods(false), T::Array[Symbol])
+        SIGNED_FINDER_METHODS = T.let(
+          defined?(ActiveRecord::SignedId) ? ActiveRecord::SignedId::ClassMethods.instance_methods(false) : [],
+          T::Array[Symbol],
+        )
         CALCULATION_METHODS = T.let(ActiveRecord::Calculations.instance_methods(false), T::Array[Symbol])
         ENUMERABLE_QUERY_METHODS = T.let([:any?, :many?, :none?, :one?], T::Array[Symbol])
         FIND_OR_CREATE_METHODS = T.let(
@@ -593,6 +600,31 @@ module Tapioca
             end
           end
 
+          SIGNED_FINDER_METHODS.each do |method_name|
+            case method_name
+            when :find_signed
+              create_common_method(
+                "find_signed",
+                common_relation_methods_module,
+                parameters: [
+                  create_param("signed_id", type: "T.untyped"),
+                  create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
+                ],
+                return_type: as_nilable_type(constant_name),
+              )
+            when :find_signed!
+              create_common_method(
+                "find_signed!",
+                common_relation_methods_module,
+                parameters: [
+                  create_param("signed_id", type: "T.untyped"),
+                  create_kw_opt_param("purpose", type: "T.untyped", default: "nil"),
+                ],
+                return_type: constant_name,
+              )
+            end
+          end
+
           CALCULATION_METHODS.each do |method_name|
             case method_name
             when :average, :maximum, :minimum

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

@@ -126,17 +126,20 @@ module Tapioca
 
         private
 
-        TYPES = T.let({
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          any: "T.untyped",
-        }.freeze, T::Hash[Symbol, String])
+        TYPES = T.let(
+          {
+            boolean: "T::Boolean",
+            integer: "Integer",
+            string: "String",
+            float: "Float",
+            date: "Date",
+            time: "Time",
+            datetime: "DateTime",
+            decimal: "BigDecimal",
+            any: "T.untyped",
+          }.freeze,
+          T::Hash[Symbol, String],
+        )
 
         sig { params(attr_type: Symbol).returns(String) }
         def type_for(attr_type)

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

@@ -85,18 +85,21 @@ module Tapioca
 
         private
 
-        TYPES = T.let({
-          boolean: "T::Boolean",
-          integer: "Integer",
-          string: "String",
-          float: "Float",
-          date: "Date",
-          time: "Time",
-          datetime: "DateTime",
-          decimal: "BigDecimal",
-          binary: "String",
-          text: "String",
-        }.freeze, T::Hash[Symbol, String])
+        TYPES = T.let(
+          {
+            boolean: "T::Boolean",
+            integer: "Integer",
+            string: "String",
+            float: "Float",
+            date: "Date",
+            time: "Time",
+            datetime: "DateTime",
+            decimal: "BigDecimal",
+            binary: "String",
+            text: "String",
+          }.freeze,
+          T::Hash[Symbol, String],
+        )
 
         sig { params(attr_type: Symbol).returns(String) }
         def type_for(attr_type)
@@ -109,9 +112,13 @@ module Tapioca
 
           klass.create_method(attribute, return_type: return_type)
           klass.create_method("#{attribute}?", return_type: "T::Boolean")
-          klass.create_method("#{attribute}=", parameters: [
-            create_param("value", type: return_type),
-          ], return_type: return_type)
+          klass.create_method(
+            "#{attribute}=",
+            parameters: [
+              create_param("value", type: return_type),
+            ],
+            return_type: return_type,
+          )
         end
       end
     end

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

@@ -48,8 +48,10 @@ module Tapioca
 
         ConstantType = type_member do
           {
-            fixed: T.all(Module,
-              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods),
+            fixed: T.all(
+              Module,
+              ::ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods,
+            ),
           }
         end
 

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

@@ -284,6 +284,11 @@ module Tapioca
             return_type: "void",
           )
 
+          klass.create_method(
+            "clear_#{field.name}",
+            return_type: "void",
+          )
+
           field
         end
 

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

@@ -119,10 +119,13 @@ module Tapioca
           mod.create_method(property.reader.to_s, return_type: type)
         end
 
-        BOOLEANS = T.let([
-          [true, false],
-          [false, true],
-        ].freeze, T::Array[[T::Boolean, T::Boolean]])
+        BOOLEANS = T.let(
+          [
+            [true, false],
+            [false, true],
+          ].freeze,
+          T::Array[[T::Boolean, T::Boolean]],
+        )
 
         sig { params(property: ::SmartProperties::Property).returns(String) }
         def type_for(property)

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

@@ -102,10 +102,13 @@ module Tapioca
           end
         end
 
-        NON_DISCOVERABLE_INCLUDERS = T.let([
-          ActionDispatch::IntegrationTest,
-          ActionView::Helpers,
-        ], T::Array[Module])
+        NON_DISCOVERABLE_INCLUDERS = T.let(
+          [
+            ActionDispatch::IntegrationTest,
+            ActionView::Helpers,
+          ],
+          T::Array[Module],
+        )
 
         class << self
           extend T::Sig

data/lib/tapioca/dsl/extensions/active_record.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+begin
+  require "active_record"
+rescue LoadError
+  return
+end
+
+module Tapioca
+  module Dsl
+    module Compilers
+      module Extensions
+        module ActiveRecord
+          attr_reader :__tapioca_delegated_types
+
+          def delegated_type(role, types:, **options)
+            @__tapioca_delegated_types ||= {}
+            @__tapioca_delegated_types[role] = { types: types, options: options }
+
+            super
+          end
+
+          ::ActiveRecord::Base.singleton_class.prepend(self)
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/helpers/active_record_column_type_helper.rb

@@ -19,33 +19,7 @@ module Tapioca
 
           column_type = @constant.attribute_types[column_name]
 
-          getter_type =
-            case column_type
-            when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
-              "::Money"
-            when ActiveRecord::Type::Integer
-              "::Integer"
-            when ActiveRecord::Type::String
-              "::String"
-            when ActiveRecord::Type::Date
-              "::Date"
-            when ActiveRecord::Type::Decimal
-              "::BigDecimal"
-            when ActiveRecord::Type::Float
-              "::Float"
-            when ActiveRecord::Type::Boolean
-              "T::Boolean"
-            when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
-              "::Time"
-            when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
-              "::ActiveSupport::TimeWithZone"
-            when ActiveRecord::Enum::EnumType
-              "::String"
-            when ActiveRecord::Type::Serialized
-              serialized_column_type(column_type)
-            else
-              handle_unknown_type(column_type)
-            end
+          getter_type = type_for_activerecord_value(column_type)
 
           column = @constant.columns_hash[column_name]
           setter_type =
@@ -71,6 +45,42 @@ module Tapioca
 
         private
 
+        sig { params(column_type: T.untyped).returns(String) }
+        def type_for_activerecord_value(column_type)
+          case column_type
+          when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
+            "::Money"
+          when ActiveRecord::Type::Integer
+            "::Integer"
+          when ActiveRecord::Type::String
+            "::String"
+          when ActiveRecord::Type::Date
+            "::Date"
+          when ActiveRecord::Type::Decimal
+            "::BigDecimal"
+          when ActiveRecord::Type::Float
+            "::Float"
+          when ActiveRecord::Type::Boolean
+            "T::Boolean"
+          when ActiveRecord::Type::DateTime, ActiveRecord::Type::Time
+            "::Time"
+          when ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
+            "::ActiveSupport::TimeWithZone"
+          when ActiveRecord::Enum::EnumType
+            "::String"
+          when ActiveRecord::Type::Serialized
+            serialized_column_type(column_type)
+          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL) &&
+            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore
+            "T::Hash[::String, ::String]"
+          when defined?(ActiveRecord::ConnectionAdapters::PostgreSQL) &&
+            ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+            "T::Array[#{type_for_activerecord_value(column_type.subtype)}]"
+          else
+            handle_unknown_type(column_type)
+          end
+        end
+
         sig { params(constant: Module).returns(T::Boolean) }
         def do_not_generate_strong_types?(constant)
           Object.const_defined?(:StrongTypeGeneration) &&

data/lib/tapioca/dsl/helpers/active_record_constants_helper.rb

@@ -13,6 +13,7 @@ module Tapioca
 
         AttributeMethodsModuleName = T.let("GeneratedAttributeMethods", String)
         AssociationMethodsModuleName = T.let("GeneratedAssociationMethods", String)
+        DelegatedTypesModuleName = T.let("GeneratedDelegatedTypeMethods", String)
 
         RelationMethodsModuleName = T.let("GeneratedRelationMethods", String)
         AssociationRelationMethodsModuleName = T.let("GeneratedAssociationRelationMethods", String)

data/lib/tapioca/dsl/pipeline.rb

@@ -128,9 +128,11 @@ module Tapioca
       def filter_anonymous_and_reloaded_constants(constants)
         # Group constants by their names
         constants_by_name = constants
-          .group_by { |c| T.must(Runtime::Reflection.name_of(c)) }
+          .group_by { |c| Runtime::Reflection.name_of(c) }
           .select { |name, _| !name.nil? }
 
+        constants_by_name = T.cast(constants_by_name, T::Hash[String, T::Array[Module]])
+
         # Find the constants that have been reloaded
         reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
 

data/lib/tapioca/gem/listeners/yard_doc.rb

@@ -7,16 +7,19 @@ module Tapioca
       class YardDoc < Base
         extend T::Sig
 
-        IGNORED_COMMENTS = T.let([
-          ":doc:",
-          ":nodoc:",
-          "typed:",
-          "frozen_string_literal:",
-          "encoding:",
-          "warn_indent:",
-          "shareable_constant_value:",
-          "rubocop:",
-        ], T::Array[String])
+        IGNORED_COMMENTS = T.let(
+          [
+            ":doc:",
+            ":nodoc:",
+            "typed:",
+            "frozen_string_literal:",
+            "encoding:",
+            "warn_indent:",
+            "shareable_constant_value:",
+            "rubocop:",
+          ],
+          T::Array[String],
+        )
 
         IGNORED_SIG_TAGS = T.let(["param", "return"], T::Array[String])
 

data/lib/tapioca/gem/pipeline.rb

@@ -241,8 +241,7 @@ module Tapioca
         klass = class_of(value)
 
         klass_name = if klass == ObjectSpace::WeakMap
-          # WeakMap is an implicit generic with one type variable
-          "ObjectSpace::WeakMap[T.untyped]"
+          sorbet_supports?(:non_generic_weak_map) ? "ObjectSpace::WeakMap" : "ObjectSpace::WeakMap[T.untyped]"
         elsif T::Generic === klass
           generic_name_of(klass)
         else

data/lib/tapioca/gemfile.rb

@@ -154,8 +154,12 @@ module Tapioca
 
       IGNORED_GEMS = T.let(
         [
-          "sorbet", "sorbet-static", "sorbet-runtime", "sorbet-static-and-runtime",
-          "debug", "fakefs",
+          "sorbet",
+          "sorbet-static",
+          "sorbet-runtime",
+          "sorbet-static-and-runtime",
+          "debug",
+          "fakefs",
         ].freeze,
         T::Array[String],
       )

data/lib/tapioca/helpers/gem_helper.rb

@@ -5,7 +5,7 @@ module Tapioca
   module GemHelper
     extend T::Sig
 
-    sig { params(app_dir: String, full_gem_path: String).returns(T::Boolean) }
+    sig { params(app_dir: T.any(String, Pathname), full_gem_path: String).returns(T::Boolean) }
     def gem_in_app_dir?(app_dir, full_gem_path)
       app_dir = to_realpath(app_dir)
       full_gem_path = to_realpath(full_gem_path)

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -161,7 +161,8 @@ module Tapioca
         RBI::Parser.parse_file(file)
       rescue RBI::ParseError => e
         say_error("\nWarning: #{e} (#{e.location})", :yellow)
-      end
+        nil
+      end.compact
 
       index.visit_all(trees)
     end
@@ -211,16 +212,22 @@ module Tapioca
 
     sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }
     def extract_methods_and_attrs(nodes)
-      T.cast(nodes.select do |node|
-        node.is_a?(RBI::Method) || node.is_a?(RBI::Attr)
-      end, T::Array[T.any(RBI::Method, RBI::Attr)])
+      T.cast(
+        nodes.select do |node|
+          node.is_a?(RBI::Method) || node.is_a?(RBI::Attr)
+        end,
+        T::Array[T.any(RBI::Method, RBI::Attr)],
+      )
     end
 
     sig { params(nodes: T::Array[RBI::Node]).returns(T::Array[T.any(RBI::Mixin, RBI::RequiresAncestor)]) }
     def extract_mixins(nodes)
-      T.cast(nodes.select do |node|
-        node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor)
-      end, T::Array[T.all(RBI::Mixin, RBI::RequiresAncestor)])
+      T.cast(
+        nodes.select do |node|
+          node.is_a?(RBI::Mixin) || node.is_a?(RBI::RequiresAncestor)
+        end,
+        T::Array[T.all(RBI::Mixin, RBI::RequiresAncestor)],
+      )
     end
 
     sig { params(nodes: T::Array[T.any(RBI::Method, RBI::Attr)]).returns(T::Array[T.any(RBI::Method, RBI::Attr)]) }

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -19,9 +19,13 @@ module Tapioca
 
     SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
 
-    FEATURE_REQUIREMENTS = T.let({
-      # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
-    }.freeze, T::Hash[Symbol, ::Gem::Requirement])
+    FEATURE_REQUIREMENTS = T.let(
+      {
+        # feature_name: ::Gem::Requirement.new(">= ___"), # https://github.com/sorbet/sorbet/pull/___
+        non_generic_weak_map: ::Gem::Requirement.new(">= 0.5.10587"), # https://github.com/sorbet/sorbet/pull/6610
+      }.freeze,
+      T::Hash[Symbol, ::Gem::Requirement],
+    )
 
     sig { params(sorbet_args: String).returns(Spoom::ExecResult) }
     def sorbet(*sorbet_args)

data/lib/tapioca/helpers/source_uri.rb

@@ -7,13 +7,16 @@ module URI
   class Source < URI::File
     extend T::Sig
 
-    COMPONENT = T.let([
-      :scheme,
-      :gem_name,
-      :gem_version,
-      :path,
-      :line_number,
-    ].freeze, T::Array[Symbol])
+    COMPONENT = T.let(
+      [
+        :scheme,
+        :gem_name,
+        :gem_version,
+        :path,
+        :line_number,
+      ].freeze,
+      T::Array[Symbol],
+    )
 
     alias_method(:gem_name, :host)
     alias_method(:line_number, :fragment)

data/lib/tapioca/loaders/gem.rb

@@ -18,10 +18,12 @@ module Tapioca
           ).void
         end
         def load_application(bundle:, prerequire:, postrequire:, default_command:)
-          loader = new(bundle: bundle,
+          loader = new(
+            bundle: bundle,
             prerequire: prerequire,
             postrequire: postrequire,
-            default_command: default_command)
+            default_command: default_command,
+          )
           loader.load
         end
       end

data/lib/tapioca/loaders/loader.rb

@@ -47,9 +47,12 @@ module Tapioca
 
         eager_load_rails_app if eager_load
       rescue LoadError, StandardError => e
-        say("Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
-          "but it failed. If your application uses Rails please ensure it can be loaded correctly before generating " \
-          "RBIs.\n#{e}", :yellow)
+        say(
+          "Tapioca attempted to load the Rails application after encountering a `config/application.rb` file, " \
+            "but it failed. If your application uses Rails please ensure it can be loaded correctly before " \
+            "generating RBIs.\n#{e}",
+          :yellow,
+        )
         say("Continuing RBI generation without loading the Rails application.")
       end
 

data/lib/tapioca/rbi_ext/model.rb

@@ -91,8 +91,13 @@ module RBI
       return unless Tapioca::RBIHelper.valid_method_name?(name)
 
       sig = RBI::Sig.new(return_type: return_type)
-      method = RBI::Method.new(name, sigs: [sig], is_singleton: class_method, visibility: visibility,
-        comments: comments)
+      method = RBI::Method.new(
+        name,
+        sigs: [sig],
+        is_singleton: class_method,
+        visibility: visibility,
+        comments: comments,
+      )
       parameters.each do |param|
         method << param.param
         sig << RBI::SigParam.new(param.param.name, param.type)

data/lib/tapioca/rbi_formatter.rb

@@ -26,12 +26,15 @@ module Tapioca
     end
   end
 
-  DEFAULT_RBI_FORMATTER = T.let(RBIFormatter.new(
-    add_sig_templates: false,
-    group_nodes: true,
-    max_line_length: nil,
-    nest_singleton_methods: true,
-    nest_non_public_methods: true,
-    sort_nodes: true,
-  ), RBIFormatter)
+  DEFAULT_RBI_FORMATTER = T.let(
+    RBIFormatter.new(
+      add_sig_templates: false,
+      group_nodes: true,
+      max_line_length: nil,
+      nest_singleton_methods: true,
+      nest_non_public_methods: true,
+      sort_nodes: true,
+    ),
+    RBIFormatter,
+  )
 end

data/lib/tapioca/runtime/trackers.rb

@@ -13,6 +13,23 @@ module Tapioca
       class << self
         extend T::Sig
 
+        sig do
+          type_parameters(:Return)
+            .params(blk: T.proc.returns(T.type_parameter(:Return)))
+            .returns(T.type_parameter(:Return))
+        end
+        def with_trackers_enabled(&blk)
+          # Currently this is a dirty hack to ensure disabling trackers
+          # doesn't work while in the block passed to this method.
+          disable_all_method = method(:disable_all!)
+          define_singleton_method(:disable_all!) {}
+          blk.call
+        ensure
+          if disable_all_method
+            define_singleton_method(:disable_all!, disable_all_method)
+          end
+        end
+
         sig { void }
         def disable_all!
           @trackers.each(&:disable!)

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -62,8 +62,8 @@ module T
         # we've created a clone of that type with the `name` method returning the
         # appropriate name for that specific concrete type.
         def name
-          if T::Generic === @raw_type || Tapioca::TypeVariableModule === @raw_type
-            # for types that are generic or are type variables, use the name
+          if T::Generic === @raw_type
+            # for types that are generic, use the name
             # returned by the "name" method of this instance
             @name ||= T.unsafe(@raw_type).name.freeze
           else
@@ -78,20 +78,42 @@ module T
   end
 
   module Utils
-    module CoercePatch
-      def coerce(val)
-        if val.is_a?(Tapioca::TypeVariableModule)
-          val.coerce_to_type_variable
-        elsif val.respond_to?(:__tapioca_override_type)
-          val.__tapioca_override_type
-        else
-          super
+    # This duplication is required to preserve backwards compatibility with sorbet-runtime versions prior to the
+    # introduction of the `Private` module in https://github.com/sorbet/sorbet/pull/6559.
+    if defined?(T::Utils::Private)
+      module Private
+        module PrivateCoercePatch
+          def coerce_and_check_module_types(val, check_val, check_module_type)
+            if val.is_a?(Tapioca::TypeVariableModule)
+              val.coerce_to_type_variable
+            elsif val.respond_to?(:__tapioca_override_type)
+              val.__tapioca_override_type
+            else
+              super
+            end
+          end
+        end
+
+        class << self
+          prepend(PrivateCoercePatch)
+        end
+      end
+    else
+      module CoercePatch
+        def coerce(val)
+          if val.is_a?(Tapioca::TypeVariableModule)
+            val.coerce_to_type_variable
+          elsif val.respond_to?(:__tapioca_override_type)
+            val.__tapioca_override_type
+          else
+            super
+          end
         end
       end
-    end
 
-    class << self
-      prepend(CoercePatch)
+      class << self
+        prepend(CoercePatch)
+      end
     end
   end
 end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.10.3"
+  VERSION = "0.10.5"
 end

data/lib/tapioca.rb

@@ -43,11 +43,14 @@ module Tapioca
   DEFAULT_TODO_FILE = T.let("#{DEFAULT_RBI_DIR}/todo.rbi", String)
   DEFAULT_ANNOTATIONS_DIR = T.let("#{DEFAULT_RBI_DIR}/annotations", String)
 
-  DEFAULT_OVERRIDES = T.let({
-    # ActiveSupport overrides some core methods with different signatures
-    # so we generate a typed: false RBI for it to suppress errors
-    "activesupport" => "false",
-  }.freeze, T::Hash[String, String])
+  DEFAULT_OVERRIDES = T.let(
+    {
+      # ActiveSupport overrides some core methods with different signatures
+      # so we generate a typed: false RBI for it to suppress errors
+      "activesupport" => "false",
+    }.freeze,
+    T::Hash[String, String],
+  )
 
   DEFAULT_RBI_MAX_LINE_LENGTH = 120
   DEFAULT_ENVIRONMENT = "development"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.3
+  version: 0.10.5
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-10 00:00:00.000000000 Z
+date: 2023-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,14 +81,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9892
+        version: 0.5.10187
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9892
+        version: 0.5.10187
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
@@ -171,6 +171,7 @@ files:
 - lib/tapioca/dsl/compilers/active_model_secure_password.rb
 - lib/tapioca/dsl/compilers/active_record_associations.rb
 - lib/tapioca/dsl/compilers/active_record_columns.rb
+- lib/tapioca/dsl/compilers/active_record_delegated_types.rb
 - lib/tapioca/dsl/compilers/active_record_enum.rb
 - lib/tapioca/dsl/compilers/active_record_fixtures.rb
 - lib/tapioca/dsl/compilers/active_record_relations.rb
@@ -192,6 +193,7 @@ files:
 - lib/tapioca/dsl/compilers/smart_properties.rb
 - lib/tapioca/dsl/compilers/state_machines.rb
 - lib/tapioca/dsl/compilers/url_helpers.rb
+- lib/tapioca/dsl/extensions/active_record.rb
 - lib/tapioca/dsl/extensions/frozen_record.rb
 - lib/tapioca/dsl/helpers/active_record_column_type_helper.rb
 - lib/tapioca/dsl/helpers/active_record_constants_helper.rb