tapioca 0.10.2 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f969345b0846479b6ab150b42641cbe90a746c59f4d995f10b4cb2dbdcaf588
-  data.tar.gz: a3dcf9bc8b505fb6be05da572b00a0efbb3f544ce7dd2303a55ed2119b34deef
+  metadata.gz: bbed9bfddb52a94735d9455ed4351c4ef1389236ceba2e19ce46d999a05536b0
+  data.tar.gz: b1a35528c1e9cfa5fd735a64d4988bfd72c0f980835d58e4a37c62d5694e3daa
 SHA512:
-  metadata.gz: 103484877f92cdb0c43d74b2b92462a977082b959ad26a2ed198895941e2e066961884f207eb167db8d6f86b941075b1216bac13d99f69ff6eb85e7bef3f7760
-  data.tar.gz: 2c11680ac5c9be37fb25b8c944e641f471c59bcb95e0e7f427d5839b56702730468e7afc71f8db22efefcad4f04ffad7a66ad15a981a9097b7217df51ca89d2b
+  metadata.gz: 6138060ec0cea66dda6f96484329626d613494404cf99f851d1dbd59249546ffdfa0b0dd58236ef63d65b93acd250eb3a46b5a3eb1a3f8491014125b18a50800
+  data.tar.gz: 266205a5dd212e87836d1d26f1f018ab83d64aaacc9b793e9a01b88c6213bda834991194896a602ce6f267ef96e3ef8f78d14464005cefcfc010bb666ddc6f3e

data/README.md

@@ -473,6 +473,8 @@ Options:
   -e, [--environment=ENVIRONMENT]                # The Rack/Rails environment to use when generating RBIs
                                                  # Default: development
   -l, [--list-compilers], [--no-list-compilers]  # List all loaded compilers
+          [--app-root=APP_ROOT]                  # The path to the Rails application
+                                                 # Default: .
   -c, [--config=<config file path>]              # Path to the Tapioca configuration file
                                                  # Default: sorbet/tapioca/config.yml
   -V, [--verbose], [--no-verbose]                # Verbose output for debugging purposes
@@ -635,6 +637,8 @@ There are two main parts to the DSL compiler API: `gather_constants` and `decora
 * The `gather_constants` class method collects all classes (or modules) that should be processed by this specific DSL compiler.
 * The `decorate` method defines how to generate the necessary RBI definitions for the gathered constants.
 
+Every compiler must declare the type member `ConstantType` in order for Sorbet to understand what the return type of the `constant` attribute reader is. It needs to be assigned the correct type variable matching the type of constants that `gather_constants` returns. This generic variable allows Sorbet to type-check method calls on the `constant` reader in your `decorate` method. See the Sorbet documentation on [generics](https://sorbet.org/docs/generics) for more information.
+
 You can now run the new RBI compiler through the normal DSL generation process (your custom compiler will be loaded automatically by Tapioca):
 
 ```shell
@@ -822,6 +826,7 @@ dsl:
   rbi_max_line_length: 120
   environment: development
   list_compilers: false
+  app_root: "."
 gem:
   outdir: sorbet/rbi/gems
   file_header: true

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

@@ -9,6 +9,8 @@ module Tapioca
 
     FILE_HEADER_OPTION_DESC = "Add a \"This file is generated\" header on top of each generated RBI file"
 
+    check_unknown_options!
+
     class_option :config,
       aliases: ["-c"],
       banner: "<config file path>",
@@ -121,6 +123,10 @@ module Tapioca
       type: :boolean,
       desc: "List all loaded compilers",
       default: false
+    option :app_root,
+      type: :string,
+      desc: "The path to the Rails application",
+      default: "."
     def dsl(*constants)
       set_environment(options)
 
@@ -136,6 +142,7 @@ module Tapioca
         verbose: options[:verbose],
         number_of_workers: options[:workers],
         rbi_formatter: rbi_formatter(options),
+        app_root: options[:app_root],
       )
 
       Tapioca.silence_warnings do
@@ -279,7 +286,10 @@ module Tapioca
         payload: options[:payload],
         number_of_workers: options[:workers],
       )
-      command.execute
+
+      Tapioca.silence_warnings do
+        command.execute
+      end
     end
 
     desc "annotations", "Pull gem RBI annotations from remote sources"
@@ -305,7 +315,10 @@ module Tapioca
         netrc_file: netrc_file(options),
         typed_overrides: options[:typed_overrides],
       )
-      command.execute
+
+      Tapioca.silence_warnings do
+        command.execute
+      end
     end
 
     map ["--version", "-v"] => :__print_version

data/lib/tapioca/commands/check_shims.rb

@@ -51,26 +51,18 @@ module Tapioca
         payload_path = T.let(nil, T.nilable(String))
 
         if @payload
-          if sorbet_supports?(:print_payload_sources)
-            Dir.mktmpdir do |dir|
-              payload_path = dir
-              result = sorbet("--no-config --print=payload-sources:#{payload_path}")
-
-              unless result.status
-                raise Thor::Error, <<~ERROR
-                  "Sorbet failed to dump payload"
-                  #{result.err}
-                ERROR
-              end
-
-              index_rbis(index, "payload", payload_path, number_of_workers: @number_of_workers)
+          Dir.mktmpdir do |dir|
+            payload_path = dir
+            result = sorbet("--no-config --print=payload-sources:#{payload_path}")
+
+            unless result.status
+              raise Thor::Error, <<~ERROR
+                "Sorbet failed to dump payload"
+                #{result.err}
+              ERROR
             end
-          else
-            raise Thor::Error, <<~ERROR
-              The version of Sorbet used in your Gemfile.lock does not support `--print=payload-sources`
-              Current: v#{SORBET_GEM_SPEC.version}
-              Required: #{FEATURE_REQUIREMENTS[:print_payload_sources]}
-            ERROR
+
+            index_rbis(index, "payload", payload_path, number_of_workers: @number_of_workers)
           end
         end
 

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/dsl.rb

@@ -22,6 +22,7 @@ module Tapioca
           auto_strictness: T::Boolean,
           gem_dir: String,
           rbi_formatter: RBIFormatter,
+          app_root: String,
         ).void
       end
       def initialize(
@@ -37,7 +38,8 @@ module Tapioca
         number_of_workers: nil,
         auto_strictness: true,
         gem_dir: DEFAULT_GEM_DIR,
-        rbi_formatter: DEFAULT_RBI_FORMATTER
+        rbi_formatter: DEFAULT_RBI_FORMATTER,
+        app_root: "."
       )
         @requested_constants = requested_constants
         @outpath = outpath
@@ -52,6 +54,7 @@ module Tapioca
         @auto_strictness = auto_strictness
         @gem_dir = gem_dir
         @rbi_formatter = rbi_formatter
+        @app_root = app_root
 
         super()
       end
@@ -61,6 +64,7 @@ module Tapioca
         Loaders::Dsl.load_application(
           tapioca_path: @tapioca_path,
           eager_load: @requested_constants.empty?,
+          app_root: @app_root,
         )
 
         pipeline = create_pipeline
@@ -87,6 +91,7 @@ module Tapioca
         Loaders::Dsl.load_application(
           tapioca_path: @tapioca_path,
           eager_load: @requested_constants.empty?,
+          app_root: @app_root,
         )
 
         if @should_verify

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/active_record_associations.rb

@@ -241,6 +241,7 @@ module Tapioca
 
           klass.create_method(
             association_name.to_s,
+            comments: association_comments(reflection),
             return_type: relation_class,
           )
           klass.create_method(
@@ -320,6 +321,40 @@ module Tapioca
           end
         end
 
+        sig { params(reflection: ReflectionType).returns(T::Array[RBI::Comment]) }
+        def association_comments(reflection)
+          anchor_name = case reflection
+          when ActiveRecord::Reflection::HasOneReflection
+            "the-has-one-association"
+          when ActiveRecord::Reflection::HasManyReflection
+            "the-has-many-association"
+          when ActiveRecord::Reflection::HasAndBelongsToManyReflection
+            "the-has-and-belongs-to-many-association"
+          when ActiveRecord::Reflection::BelongsToReflection
+            "the-belongs-to-association"
+          when ActiveRecord::Reflection::ThroughReflection
+            delegate_reflection = reflection.send(:delegate_reflection)
+            declaration = declaration(delegate_reflection)
+            if T.must(declaration).match?("has_one")
+              "the-has-one-through-association"
+            else
+              "the-has-many-through-association"
+            end
+          end
+
+          if anchor_name
+            url = "https://guides.rubyonrails.org/association_basics.html##{anchor_name}"
+            association_name = anchor_name.sub(/^the-(.*)-association$/, '\1')
+            comment = <<~MSG
+              This method is created by ActiveRecord on the `#{reflection.active_record.name}` class because it declared `#{declaration(reflection)}`.
+              🔗 [Rails guide for `#{association_name.gsub("-", "_")}` association](#{url})
+            MSG
+            [RBI::Comment.new(comment)]
+          else
+            []
+          end
+        end
+
         sig do
           params(
             reflection: ReflectionType,

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_relations.rb

@@ -217,6 +217,7 @@ module Tapioca
           T::Array[Symbol],
         )
         FINDER_METHODS = T.let(ActiveRecord::FinderMethods.instance_methods(false), T::Array[Symbol])
+        SIGNED_FINDER_METHODS = T.let(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(
@@ -243,15 +244,9 @@ module Tapioca
           # The model always extends the generated relation module
           model.create_extend(RelationMethodsModuleName)
 
-          # This feature is only available in versions of Sorbet with special support for
-          # handling `NilClass` returns from `to_ary`. We should not be typing `to_ary` like
-          # this for older versions since it will make all flatten operations be
-          # `T::Array[NilClass]`, otherwise.
-          if sorbet_supports?(:to_ary_nil_support)
-            # Type the `to_ary` method as returning `NilClass` so that flatten stops recursing
-            # See https://github.com/sorbet/sorbet/pull/4706 for details
-            model.create_method("to_ary", return_type: "NilClass", visibility: RBI::Private.new)
-          end
+          # Type the `to_ary` method as returning `NilClass` so that flatten stops recursing
+          # See https://github.com/sorbet/sorbet/pull/4706 for details
+          model.create_method("to_ary", return_type: "NilClass", visibility: RBI::Private.new)
 
           create_relation_class(model)
           create_association_relation_class(model)
@@ -599,6 +594,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/protobuf.rb

@@ -95,7 +95,18 @@ module Tapioca
               case descriptor
               when Google::Protobuf::EnumDescriptor
                 descriptor.to_h.each do |sym, val|
-                  klass.create_constant(sym.to_s, value: val.to_s)
+                  # For each enum value, create a namespaced constant on the root rather than an un-namespaced
+                  # constant within the class. This is because un-namespaced constants might conflict with reserved
+                  # Ruby words, such as "BEGIN." By namespacing them, we avoid this problem.
+                  #
+                  # Invalid syntax:
+                  # class Foo
+                  #   BEGIN = 3
+                  # end
+                  #
+                  # Valid syntax:
+                  # Foo::BEGIN = 3
+                  root.create_constant("#{constant}::#{sym}", value: val.to_s)
                 end
 
                 klass.create_method(
@@ -273,6 +284,11 @@ module Tapioca
             return_type: "void",
           )
 
+          klass.create_method(
+            "clear_#{field.name}",
+            return_type: "void",
+          )
+
           field
         end
 

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

@@ -41,6 +41,8 @@ module Tapioca
               "::ActiveSupport::TimeWithZone"
             when ActiveRecord::Enum::EnumType
               "::String"
+            when ActiveRecord::Type::Serialized
+              serialized_column_type(column_type)
             else
               handle_unknown_type(column_type)
             end
@@ -119,6 +121,23 @@ module Tapioca
             "T.any(::String, ::Symbol)"
           end
         end
+
+        sig { params(column_type: ActiveRecord::Type::Serialized).returns(String) }
+        def serialized_column_type(column_type)
+          case column_type.coder
+          when ActiveRecord::Coders::YAMLColumn
+            case column_type.coder.object_class
+            when Array.singleton_class
+              "T::Array[T.untyped]"
+            when Hash.singleton_class
+              "T::Hash[T.untyped, T.untyped]"
+            else
+              "T.untyped"
+            end
+          else
+            "T.untyped"
+          end
+        end
       end
     end
   end

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/helpers/graphql_type_helper.rb

@@ -25,7 +25,7 @@ module Tapioca
           when GraphQL::Types::ISO8601Date.singleton_class
             type_for_constant(Date)
           when GraphQL::Types::ISO8601DateTime.singleton_class
-            type_for_constant(DateTime)
+            type_for_constant(Time)
           when GraphQL::Types::JSON.singleton_class
             "T::Hash[::String, T.untyped]"
           when GraphQL::Schema::Enum.singleton_class

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/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
@@ -342,7 +341,7 @@ module Tapioca
 
       sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
       def defined_in_gem?(constant, strict: true)
-        files = Set.new(get_file_candidates(constant))
+        files = get_file_candidates(constant)
           .merge(Runtime::Trackers::ConstantDefinition.files_for(constant))
 
         return !strict if files.empty?
@@ -352,13 +351,11 @@ module Tapioca
         end
       end
 
-      sig { params(constant: Module).returns(T::Array[String]) }
+      sig { params(constant: Module).returns(T::Set[String]) }
       def get_file_candidates(constant)
-        wrapped_module = Pry::WrappedModule.new(constant)
-
-        wrapped_module.send(:method_candidates).flatten.filter_map(&:source_file).uniq
+        file_candidates_for(constant)
       rescue ArgumentError, NameError
-        []
+        Set.new
       end
 
       sig { params(name: String).void }

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

data/lib/tapioca/helpers/rbi_helper.rb

@@ -23,22 +23,14 @@ module Tapioca
       def serialize_type_variable(type, variance, fixed, upper, lower)
         variance = nil if variance == :invariant
 
-        bounds = []
-        bounds << "fixed: #{fixed}" if fixed
-        bounds << "lower: #{lower}" if lower
-        bounds << "upper: #{upper}" if upper
-
-        parameters = []
         block = []
+        block << "fixed: #{fixed}" if fixed
+        block << "lower: #{lower}" if lower
+        block << "upper: #{upper}" if upper
 
+        parameters = []
         parameters << ":#{variance}" if variance
 
-        if sorbet_supports?(:type_variable_block_syntax)
-          block = bounds
-        else
-          parameters.concat(bounds)
-        end
-
         serialized = type.dup
         serialized << "(#{parameters.join(", ")})" unless parameters.empty?
         serialized << " { { #{block.join(", ")} } }" unless block.empty?

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -20,9 +20,8 @@ module Tapioca
     SORBET_PAYLOAD_URL = "https://github.com/sorbet/sorbet/tree/master/rbi"
 
     FEATURE_REQUIREMENTS = T.let({
-      to_ary_nil_support: ::Gem::Requirement.new(">= 0.5.9220"),         # https://github.com/sorbet/sorbet/pull/4706
-      print_payload_sources: ::Gem::Requirement.new(">= 0.5.9818"),      # https://github.com/sorbet/sorbet/pull/5504
-      type_variable_block_syntax: ::Gem::Requirement.new(">= 0.5.9892"), # https://github.com/sorbet/sorbet/pull/5639
+      # 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) }

data/lib/tapioca/loaders/dsl.rb

@@ -9,9 +9,9 @@ module Tapioca
       class << self
         extend T::Sig
 
-        sig { params(tapioca_path: String, eager_load: T::Boolean).void }
-        def load_application(tapioca_path:, eager_load: true)
-          loader = new(tapioca_path: tapioca_path)
+        sig { params(tapioca_path: String, eager_load: T::Boolean, app_root: String).void }
+        def load_application(tapioca_path:, eager_load: true, app_root: ".")
+          loader = new(tapioca_path: tapioca_path, app_root: app_root)
           loader.load
         end
       end
@@ -26,12 +26,13 @@ module Tapioca
 
       protected
 
-      sig { params(tapioca_path: String, eager_load: T::Boolean).void }
-      def initialize(tapioca_path:, eager_load: true)
+      sig { params(tapioca_path: String, eager_load: T::Boolean, app_root: String).void }
+      def initialize(tapioca_path:, eager_load: true, app_root: ".")
         super()
 
         @tapioca_path = tapioca_path
         @eager_load = eager_load
+        @app_root = app_root
       end
 
       sig { void }
@@ -64,6 +65,7 @@ module Tapioca
         load_rails_application(
           environment_load: true,
           eager_load: @eager_load,
+          app_root: @app_root,
         )
 
         say("Done", :green)
@@ -71,7 +73,7 @@ module Tapioca
 
       sig { void }
       def abort_if_pending_migrations!
-        return unless File.exist?("config/application.rb")
+        return unless File.exist?("#{@app_root}/config/application.rb")
         return unless defined?(::Rake)
 
         Rails.application.load_tasks

data/lib/tapioca/loaders/loader.rb

@@ -33,16 +33,16 @@ module Tapioca
         load_rails_engines
       end
 
-      sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
-      def load_rails_application(environment_load: false, eager_load: false)
-        return unless File.exist?("config/application.rb")
+      sig { params(environment_load: T::Boolean, eager_load: T::Boolean, app_root: String).void }
+      def load_rails_application(environment_load: false, eager_load: false, app_root: ".")
+        return unless File.exist?("#{app_root}/config/application.rb")
 
         silence_deprecations
 
         if environment_load
-          require "./config/environment"
+          require "./#{app_root}/config/environment"
         else
-          require "./config/application"
+          require "./#{app_root}/config/application"
         end
 
         eager_load_rails_app if eager_load

data/lib/tapioca/rbi_ext/model.rb

@@ -83,13 +83,16 @@ module RBI
         return_type: String,
         class_method: T::Boolean,
         visibility: RBI::Visibility,
+        comments: T::Array[RBI::Comment],
       ).void
     end
-    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new)
+    def create_method(name, parameters: [], return_type: "T.untyped", class_method: false, visibility: RBI::Public.new,
+      comments: [])
       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)
+      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/runtime/reflection.rb

@@ -183,6 +183,61 @@ module Tapioca
 
         T.cast(result, Module)
       end
+
+      sig { params(constant: Module).returns(T::Set[String]) }
+      def file_candidates_for(constant)
+        relevant_methods_for(constant).filter_map do |method|
+          method.source_location&.first
+        end.to_set
+      end
+
+      private
+
+      sig { params(constant: Module).returns(T::Array[UnboundMethod]) }
+      def relevant_methods_for(constant)
+        methods = methods_for(constant).select(&:source_location)
+          .reject { |x| method_defined_by_forwardable_module?(x) }
+
+        return methods unless methods.empty?
+
+        constants_of(constant).flat_map do |const_name|
+          if (mod = child_module_for_parent_with_name(constant, const_name.to_s))
+            relevant_methods_for(mod)
+          else
+            []
+          end
+        end
+      end
+
+      sig { params(constant: Module).returns(T::Array[UnboundMethod]) }
+      def methods_for(constant)
+        modules = [constant, singleton_class_of(constant)]
+        method_list_methods = [
+          PUBLIC_INSTANCE_METHODS_METHOD,
+          PROTECTED_INSTANCE_METHODS_METHOD,
+          PRIVATE_INSTANCE_METHODS_METHOD,
+        ]
+
+        modules.product(method_list_methods).flat_map do |mod, method_list_method|
+          method_list_method.bind_call(mod, false).map { |name| mod.instance_method(name) }
+        end
+      end
+
+      sig { params(parent: Module, name: String).returns(T.nilable(Module)) }
+      def child_module_for_parent_with_name(parent, name)
+        return if parent.autoload?(name)
+
+        child = constantize(name, inherit: true, namespace: parent)
+        return unless Module === child
+        return unless name_of(child) == "#{name_of(parent)}::#{name}"
+
+        child
+      end
+
+      sig { params(method: UnboundMethod).returns(T::Boolean) }
+      def method_defined_by_forwardable_module?(method)
+        method.source_location&.first == Object.const_source_location(:Forwardable)&.first
+      end
     end
   end
 end

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/static/symbol_loader.rb

@@ -62,14 +62,14 @@ module Tapioca
 
         sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
         def symbols_from_paths(paths)
-          output = T.cast(Tempfile.create("sorbet") do |file|
+          output = Tempfile.create("sorbet") do |file|
             file.write(Array(paths).join("\n"))
             file.flush
 
             symbol_table_json_from("@#{file.path.shellescape}")
-          end, T.nilable(String))
+          end
 
-          return Set.new if output.nil? || output.empty?
+          return Set.new if output.empty?
 
           SymbolTableParser.parse_json(output)
         end

data/lib/tapioca/static/symbol_table_parser.rb

@@ -43,6 +43,12 @@ module Tapioca
 
           next if name.nil?
           next unless SKIP_PARSE_KINDS.include?(kind)
+
+          # Turn singleton class names to attached class names
+          if (match_data = name.match(/<Class:(.*)>/))
+            name = match_data[1]
+          end
+
           next if name.match?(/[<>()$]/)
           next if name.match?(/^[0-9]+$/)
           next if name == "T::Helpers"

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.4
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-09-29 00:00:00.000000000 Z
+date: 2022-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,20 +55,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.21.0
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.12.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.12.2
 - !ruby/object:Gem::Dependency
   name: rbi
   requirement: !ruby/object:Gem::Requirement
@@ -78,7 +64,7 @@ dependencies:
         version: 0.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -88,21 +74,21 @@ dependencies:
         version: 0.0.0
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.16
 - !ruby/object:Gem::Dependency
   name: sorbet-static-and-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.5.10187
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.9204
+        version: 0.5.10187
 - !ruby/object:Gem::Dependency
   name: spoom
   requirement: !ruby/object:Gem::Requirement
@@ -185,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
@@ -206,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