tapioca 0.11.6 → 0.11.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ee3bcaf55b533576a46aa60a0a03b946552ee3fba42f8b136108dea8d0888ba
-  data.tar.gz: b0d12f84750676a3b99eb7e76e10d3be64a92359f5a440c0c8c5ef9c7f3e5ac9
+  metadata.gz: 68b1a51d995ed5925df2983b0fdc55ef14bdfb828780077035048f1a6305ad74
+  data.tar.gz: 9689fa2965d90459e47618b2d41df0e24acdb9599d3552205ed973fa37126c9b
 SHA512:
-  metadata.gz: cf6bb9e139fabc27048c5237f0e8662f5972051ae01fd1fcaae34f11c23fceb471f7d7118df9dabd507b24f7fccf8d4a6208dfd02d08ed37453b1ef2679ba04f
-  data.tar.gz: 2860aaa02b120a10182e7928fdc54f48d6eca933f4eee8ec51df78ae59043bc59c6cc839b1a65d2fe610c3ec545ad68b2caf400821b32c7ee029ca0046b88009
+  metadata.gz: 78cfdeb935bd82157c0f98344af6e131f5c5d0b256076ac69b1518f044f08ace764cfe7efe153928c7209a451ce194ae7d2ac82cebf68c1aed937b3016ba6cb3
+  data.tar.gz: d51e8ca0aafb1764efa553387d2569aec765c0eb6d5ac8344843b131d75fa6b2daa5bca6daa4304229eb6313ef244752fb1ec66c2c10d5868ee8983174bf5f3e

data/README.md

@@ -163,36 +163,38 @@ Usage:
   tapioca gem [gem...]
 
 Options:
-  --out, -o, [--outdir=directory]                             # The output directory for generated gem RBI files
-                                                              # Default: sorbet/rbi/gems
-          [--file-header], [--no-file-header]                 # Add a "This file is generated" header on top of each generated RBI file
-                                                              # Default: true
-          [--all], [--no-all]                                 # Regenerate RBI files for all gems
-  --pre, -b, [--prerequire=file]                              # A file to be required before Bundler.require is called
-  --post, -a, [--postrequire=file]                            # A file to be required after Bundler.require is called
-                                                              # Default: sorbet/tapioca/require.rb
-  -x, [--exclude=gem [gem ...]]                               # Exclude the given gem(s) from RBI generation
-  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]  # Override for typed sigils for generated gem RBIs
-                                                              # Default: {"activesupport"=>"false"}
-          [--verify], [--no-verify]                           # Verify RBIs are up-to-date
-          [--doc], [--no-doc]                                 # Include YARD documentation from sources when generating RBIs. Warning: this might be slow
-                                                              # Default: true
-          [--loc], [--no-loc]                                 # Include comments with source location when generating RBIs
-                                                              # Default: true
-          [--exported-gem-rbis], [--no-exported-gem-rbis]     # Include RBIs found in the `rbi/` directory of the gem
-                                                              # Default: true
-  -w, [--workers=N]                                           # Number of parallel workers to use when generating RBIs (default: auto)
-          [--auto-strictness], [--no-auto-strictness]         # Autocorrect strictness in gem RBIs in case of conflict with the DSL RBIs
-                                                              # Default: true
-  --dsl-dir, [--dsl-dir=directory]                            # The DSL directory used to correct gems strictnesses
-                                                              # Default: sorbet/rbi/dsl
-          [--rbi-max-line-length=N]                           # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
-                                                              # Default: 120
-  -e, [--environment=ENVIRONMENT]                             # The Rack/Rails environment to use when generating RBIs
-                                                              # Default: development
-  -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
+  --out, -o,   [--outdir=directory]                                   # The output directory for generated gem RBI files
+                                                                      # Default: sorbet/rbi/gems
+               [--file-header], [--no-file-header]                    # Add a "This file is generated" header on top of each generated RBI file
+                                                                      # Default: true
+               [--all], [--no-all]                                    # Regenerate RBI files for all gems
+  --pre, -b,   [--prerequire=file]                                    # A file to be required before Bundler.require is called
+  --post, -a,  [--postrequire=file]                                   # A file to be required after Bundler.require is called
+                                                                      # Default: sorbet/tapioca/require.rb
+  -x,          [--exclude=gem [gem ...]]                              # Exclude the given gem(s) from RBI generation
+  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]          # Override for typed sigils for generated gem RBIs
+                                                                      # Default: {"activesupport"=>"false"}
+               [--verify], [--no-verify]                              # Verify RBIs are up-to-date
+               [--doc], [--no-doc]                                    # Include YARD documentation from sources when generating RBIs. Warning: this might be slow
+                                                                      # Default: true
+               [--loc], [--no-loc]                                    # Include comments with source location when generating RBIs
+                                                                      # Default: true
+               [--exported-gem-rbis], [--no-exported-gem-rbis]        # Include RBIs found in the `rbi/` directory of the gem
+                                                                      # Default: true
+  -w,          [--workers=N]                                          # Number of parallel workers to use when generating RBIs (default: auto)
+               [--auto-strictness], [--no-auto-strictness]            # Autocorrect strictness in gem RBIs in case of conflict with the DSL RBIs
+                                                                      # Default: true
+  --dsl-dir,   [--dsl-dir=directory]                                  # The DSL directory used to correct gems strictnesses
+                                                                      # Default: sorbet/rbi/dsl
+               [--rbi-max-line-length=N]                              # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
+                                                                      # Default: 120
+  -e,          [--environment=ENVIRONMENT]                            # The Rack/Rails environment to use when generating RBIs
+                                                                      # Default: development
+               [--halt-upon-load-error], [--no-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
+                                                                      # Default: true
+  -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
 
 generate RBIs from gems
 ```
@@ -347,16 +349,16 @@ Usage:
   tapioca annotations
 
 Options:
-          [--sources=one two three]                           # URIs of the sources to pull gem RBI annotations from
+               [--sources=one two three]                      # URIs of the sources to pull gem RBI annotations from
                                                               # Default: ["https://raw.githubusercontent.com/Shopify/rbi-central/main"]
-          [--netrc], [--no-netrc]                             # Use .netrc to authenticate to private sources
+               [--netrc], [--no-netrc]                        # Use .netrc to authenticate to private sources
                                                               # Default: true
-          [--netrc-file=NETRC_FILE]                           # Path to .netrc file
-          [--auth=AUTH]                                       # HTTP authorization header for private sources
+               [--netrc-file=NETRC_FILE]                      # Path to .netrc file
+               [--auth=AUTH]                                  # HTTP authorization header for private sources
   --typed, -t, [--typed-overrides=gem:level [gem:level ...]]  # Override for typed sigils for pulled annotations
-  -c, [--config=<config file path>]                           # Path to the Tapioca configuration file
+  -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
+  -V,          [--verbose], [--no-verbose]                    # Verbose output for debugging purposes
 
 Pull gem RBI annotations from remote sources
 ```
@@ -458,26 +460,28 @@ Usage:
   tapioca dsl [constant...]
 
 Options:
-  --out, -o, [--outdir=directory]                # The output directory for generated DSL RBI files
-                                                 # Default: sorbet/rbi/dsl
-          [--file-header], [--no-file-header]    # Add a "This file is generated" header on top of each generated RBI file
-                                                 # Default: true
-          [--only=compiler [compiler ...]]       # Only run supplied DSL compiler(s)
-          [--exclude=compiler [compiler ...]]    # Exclude supplied DSL compiler(s)
-          [--verify], [--no-verify]              # Verifies RBIs are up-to-date
-  -q, [--quiet], [--no-quiet]                    # Suppresses file creation output
-  -w, [--workers=N]                              # Number of parallel workers to use when generating RBIs (default: 2)
-                                                 # Default: 2
-          [--rbi-max-line-length=N]              # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
-                                                 # Default: 120
-  -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
+  --out, -o, [--outdir=directory]                                   # The output directory for generated DSL RBI files
+                                                                    # Default: sorbet/rbi/dsl
+             [--file-header], [--no-file-header]                    # Add a "This file is generated" header on top of each generated RBI file
+                                                                    # Default: true
+             [--only=compiler [compiler ...]]                       # Only run supplied DSL compiler(s)
+             [--exclude=compiler [compiler ...]]                    # Exclude supplied DSL compiler(s)
+             [--verify], [--no-verify]                              # Verifies RBIs are up-to-date
+  -q,        [--quiet], [--no-quiet]                                # Suppresses file creation output
+  -w,        [--workers=N]                                          # Number of parallel workers to use when generating RBIs (default: 2)
+                                                                    # Default: 2
+             [--rbi-max-line-length=N]                              # Set the max line length of generated RBIs. Signatures longer than the max line length will be wrapped
+                                                                    # Default: 120
+  -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: .
+             [--halt-upon-load-error], [--no-halt-upon-load-error]  # Halt upon a load error while loading the Rails application
+                                                                    # Default: true
+  -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
 
 generate RBIs for dynamic methods
 ```
@@ -827,6 +831,7 @@ dsl:
   environment: development
   list_compilers: false
   app_root: "."
+  halt_upon_load_error: true
 gem:
   outdir: sorbet/rbi/gems
   file_header: true
@@ -845,6 +850,7 @@ gem:
   dsl_dir: sorbet/rbi/dsl
   rbi_max_line_length: 120
   environment: development
+  halt_upon_load_error: true
 check_shims:
   gem_rbi_dir: sorbet/rbi/gems
   dsl_rbi_dir: sorbet/rbi/dsl

data/lib/tapioca/bundler_ext/auto_require_hook.rb

@@ -0,0 +1,69 @@
+# typed: true
+# frozen_string_literal: true
+
+module Tapioca
+  module BundlerExt
+    # This is a module that gets prepended to `Bundler::Dependency` and
+    # makes sure even gems marked as `require: false` are required during
+    # `Bundler.require`.
+    module AutoRequireHook
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { ::Bundler::Dependency }
+
+      @exclude = T.let([], T::Array[String])
+      @enabled = T.let(false, T::Boolean)
+
+      class << self
+        extend T::Sig
+
+        sig { params(name: T.untyped).returns(T::Boolean) }
+        def excluded?(name)
+          @exclude.include?(name)
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        sig do
+          type_parameters(:Result).params(
+            exclude: T::Array[String],
+            blk: T.proc.returns(T.type_parameter(:Result)),
+          ).returns(T.type_parameter(:Result))
+        end
+        def override_require_false(exclude:, &blk)
+          @enabled = true
+          @exclude = exclude
+          blk.call
+        ensure
+          @enabled = false
+        end
+      end
+
+      sig { returns(T.untyped).checked(:never) }
+      def autorequire
+        value = super
+
+        # If autorequire is not enabled, we don't want to force require gems
+        return value unless AutoRequireHook.enabled?
+
+        # If the gem is excluded, we don't want to force require it, in case
+        # it has side-effects users don't want. For example, `fakefs` gem, if
+        # loaded, takes over filesystem operations.
+        return value if AutoRequireHook.excluded?(name)
+
+        # If a gem is marked as `require: false`, then its `autorequire`
+        # value will be `[]`. But, we want those gems to be loaded for our
+        # purposes as well, so we return `nil` in those cases, instead, which
+        # means `require: true`.
+        return nil if value == []
+
+        value
+      end
+
+      ::Bundler::Dependency.prepend(self)
+    end
+  end
+end

data/lib/tapioca/cli.rb

@@ -130,6 +130,10 @@ module Tapioca
       type: :string,
       desc: "The path to the Rails application",
       default: "."
+    option :halt_upon_load_error,
+      type: :boolean,
+      desc: "Halt upon a load error while loading the Rails application",
+      default: true
     def dsl(*constant_or_paths)
       set_environment(options)
 
@@ -150,6 +154,7 @@ module Tapioca
         number_of_workers: options[:workers],
         rbi_formatter: rbi_formatter(options),
         app_root: options[:app_root],
+        halt_upon_load_error: options[:halt_upon_load_error],
       )
 
       Tapioca.silence_warnings do
@@ -235,6 +240,10 @@ module Tapioca
       type: :string,
       desc: "The Rack/Rails environment to use when generating RBIs",
       default: DEFAULT_ENVIRONMENT
+    option :halt_upon_load_error,
+      type: :boolean,
+      desc: "Halt upon a load error while loading the Rails application",
+      default: true
     def gem(*gems)
       Tapioca.silence_warnings do
         set_environment(options)
@@ -257,6 +266,7 @@ module Tapioca
           auto_strictness: options[:auto_strictness],
           dsl_dir: options[:dsl_dir],
           rbi_formatter: rbi_formatter(options),
+          halt_upon_load_error: options[:halt_upon_load_error],
         )
 
         raise MalformattedArgumentError, "Options '--all' and '--verify' are mutually exclusive" if all && verify

data/lib/tapioca/commands/dsl.rb

@@ -24,6 +24,7 @@ module Tapioca
           gem_dir: String,
           rbi_formatter: RBIFormatter,
           app_root: String,
+          halt_upon_load_error: T::Boolean,
         ).void
       end
       def initialize(
@@ -41,7 +42,8 @@ module Tapioca
         auto_strictness: true,
         gem_dir: DEFAULT_GEM_DIR,
         rbi_formatter: DEFAULT_RBI_FORMATTER,
-        app_root: "."
+        app_root: ".",
+        halt_upon_load_error: true
       )
         @requested_constants = requested_constants
         @requested_paths = requested_paths
@@ -58,6 +60,7 @@ module Tapioca
         @gem_dir = gem_dir
         @rbi_formatter = rbi_formatter
         @app_root = app_root
+        @halt_upon_load_error = halt_upon_load_error
 
         super()
       end
@@ -68,6 +71,7 @@ module Tapioca
           tapioca_path: @tapioca_path,
           eager_load: @requested_constants.empty? && @requested_paths.empty?,
           app_root: @app_root,
+          halt_upon_load_error: @halt_upon_load_error,
         )
 
         pipeline = create_pipeline
@@ -95,6 +99,7 @@ module Tapioca
           tapioca_path: @tapioca_path,
           eager_load: @requested_constants.empty? && @requested_paths.empty?,
           app_root: @app_root,
+          halt_upon_load_error: @halt_upon_load_error,
         )
 
         if @should_verify

data/lib/tapioca/commands/gem.rb

@@ -23,6 +23,7 @@ module Tapioca
           auto_strictness: T::Boolean,
           dsl_dir: String,
           rbi_formatter: RBIFormatter,
+          halt_upon_load_error: T::Boolean,
         ).void
       end
       def initialize(
@@ -39,7 +40,8 @@ module Tapioca
         number_of_workers: nil,
         auto_strictness: true,
         dsl_dir: DEFAULT_DSL_DIR,
-        rbi_formatter: DEFAULT_RBI_FORMATTER
+        rbi_formatter: DEFAULT_RBI_FORMATTER,
+        halt_upon_load_error: true
       )
         @gem_names = gem_names
         @exclude = exclude
@@ -61,6 +63,7 @@ module Tapioca
         @include_doc = T.let(include_doc, T::Boolean)
         @include_loc = T.let(include_loc, T::Boolean)
         @include_exported_rbis = include_exported_rbis
+        @halt_upon_load_error = halt_upon_load_error
       end
 
       sig { override.void }
@@ -70,6 +73,7 @@ module Tapioca
           prerequire: @prerequire,
           postrequire: @postrequire,
           default_command: default_command(:require),
+          halt_upon_load_error: @halt_upon_load_error,
         )
 
         gem_queue = gems_to_generate(@gem_names).reject { |gem| @exclude.include?(gem.name) }
@@ -245,6 +249,7 @@ module Tapioca
               prerequire: @prerequire,
               postrequire: @postrequire,
               default_command: default_command(:require),
+              halt_upon_load_error: @halt_upon_load_error,
             )
 
             Executor.new(gems, number_of_workers: @number_of_workers).run_in_parallel do |gem_name|

data/lib/tapioca/dsl/compiler.rb

@@ -43,10 +43,10 @@ module Tapioca
 
         private
 
-        sig { returns(T::Enumerable[Class]) }
+        sig { returns(T::Enumerable[T::Class[T.anything]]) }
         def all_classes
-          @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[Class]))
-          @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[Class]).each
+          @all_classes = T.let(@all_classes, T.nilable(T::Enumerable[T::Class[T.anything]]))
+          @all_classes ||= T.cast(ObjectSpace.each_object(Class), T::Enumerable[T::Class[T.anything]]).each
         end
 
         sig { returns(T::Enumerable[Module]) }

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

@@ -74,7 +74,7 @@ module Tapioca
             T::Array[String],
           )
 
-        ConstantType = type_member { { fixed: T.all(::AASM::ClassMethods, Class) } }
+        ConstantType = type_member { { fixed: T.all(T::Class[::AASM], ::AASM::ClassMethods) } }
 
         sig { override.void }
         def decorate

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

@@ -39,7 +39,9 @@ module Tapioca
       class ActiveModelAttributes < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(Class, ::ActiveModel::Attributes::ClassMethods) } }
+        ConstantType = type_member do
+          { fixed: T.all(T::Class[::ActiveModel::Attributes], ::ActiveModel::Attributes::ClassMethods) }
+        end
 
         sig { override.void }
         def decorate

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

@@ -60,7 +60,9 @@ module Tapioca
       class ActiveModelSecurePassword < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(Class, ::ActiveModel::SecurePassword::ClassMethods) } }
+        ConstantType = type_member do
+          { fixed: T.all(T::Class[::ActiveModel::SecurePassword], ::ActiveModel::SecurePassword::ClassMethods) }
+        end
 
         sig { override.void }
         def decorate

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

@@ -110,10 +110,11 @@ module Tapioca
             return_type: "ActiveSupport::StringInquirer",
           )
 
+          return_type = sorbet_supports?(:generic_class) ? "T::Class[T.anything]" : "Class"
           mod.create_method(
             "#{role}_class",
             parameters: [],
-            return_type: "Class",
+            return_type: return_type,
           )
 
           mod.create_method(

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

@@ -70,15 +70,24 @@ module Tapioca
 
         private
 
-        sig { returns(Class) }
+        sig { returns(T::Class[ActiveRecord::TestFixtures]) }
         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),
+            T.cast(
+              Class.new do
+                T.unsafe(self).include(ActiveRecord::TestFixtures)
+
+                T.unsafe(self).fixture_path = Rails.root.join("test", "fixtures")
+                # https://github.com/rails/rails/blob/7c70791470fc517deb7c640bead9f1b47efb5539/activerecord/lib/active_record/test_fixtures.rb#L46
+                singleton_class.define_method(:file_fixture_path) do
+                  Rails.root.join("test", "fixtures", "files")
+                end
+
+                T.unsafe(self).fixtures(:all)
+              end,
+              T::Class[ActiveRecord::TestFixtures],
+            ),
+            T.nilable(T::Class[ActiveRecord::TestFixtures]),
           )
         end
 

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

@@ -70,7 +70,9 @@ module Tapioca
       class Kredis < Compiler
         extend T::Sig
 
-        ConstantType = type_member { { fixed: T.all(Class, ::Kredis::Attributes::ClassMethods, Extensions::Kredis) } }
+        ConstantType = type_member do
+          { fixed: T.all(T::Class[::Kredis::Attributes], ::Kredis::Attributes::ClassMethods, Extensions::Kredis) }
+        end
 
         sig { override.void }
         def decorate

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

@@ -78,7 +78,7 @@ module Tapioca
 
         extend T::Sig
 
-        ConstantType = type_member { { fixed: Module } }
+        ConstantType = type_member { { fixed: T::Class[T.anything] } }
 
         FIELD_RE = /^[a-z_][a-zA-Z0-9_]*$/
 
@@ -206,7 +206,7 @@ module Tapioca
             # > field, even if it was not defined in the enum.
             "T.any(Symbol, Integer)"
           when :message
-            descriptor.subtype.msgclass.name
+            descriptor.subtype.msgclass.name || "T.untyped"
           when :int32, :int64, :uint32, :uint64
             "Integer"
           when :double, :float
@@ -225,14 +225,24 @@ module Tapioca
           descriptor.label == :optional && descriptor.type == :message
         end
 
+        sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(T::Boolean) }
+        def map_type?(descriptor)
+          # Defensively make sure that we are dealing with a repeated field
+          return false unless descriptor.label == :repeated
+
+          # Try to create a new instance with the field that maps to the descriptor name
+          # being assinged a hash value. If this goes through, then it's a map type.
+          constant.new(**{ descriptor.name => {} })
+          true
+        rescue ArgumentError
+          # This means the descriptor is not a map type
+          false
+        end
+
         sig { params(descriptor: Google::Protobuf::FieldDescriptor).returns(Field) }
         def field_of(descriptor)
           if descriptor.label == :repeated
-            # Here we're going to check if the submsg_name is named according to
-            # how Google names map entries.
-            # https://github.com/protocolbuffers/protobuf/blob/f82e26/ruby/ext/google/protobuf_c/defs.c#L1963-L1966
-            if descriptor.submsg_name.to_s.end_with?("_MapEntry_#{descriptor.name}") ||
-                descriptor.submsg_name.to_s.end_with?("FieldsEntry")
+            if map_type?(descriptor)
               key = descriptor.subtype.lookup("key")
               value = descriptor.subtype.lookup("value")
 

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

@@ -20,7 +20,7 @@ module Tapioca
 
           compile_method(node, symbol, constant, initialize_method_for(constant))
           compile_directly_owned_methods(node, symbol, constant)
-          compile_directly_owned_methods(node, symbol, singleton_class_of(constant))
+          compile_directly_owned_methods(node, symbol, singleton_class_of(constant), attached_class: constant)
         end
 
         sig do
@@ -29,14 +29,22 @@ module Tapioca
             module_name: String,
             mod: Module,
             for_visibility: T::Array[Symbol],
+            attached_class: T.nilable(Module),
           ).void
         end
-        def compile_directly_owned_methods(tree, module_name, mod, for_visibility = [:public, :protected, :private])
+        def compile_directly_owned_methods(
+          tree,
+          module_name,
+          mod,
+          for_visibility = [:public, :protected, :private],
+          attached_class: nil
+        )
           method_names_by_visibility(mod)
             .delete_if { |visibility, _method_list| !for_visibility.include?(visibility) }
             .each do |visibility, method_list|
               method_list.sort!.map do |name|
                 next if name == :initialize
+                next if method_new_in_abstract_class?(attached_class, name)
 
                 vis = case visibility
                 when :protected
@@ -180,6 +188,19 @@ module Tapioca
             .include?(method_name.gsub(/=$/, "").to_sym)
         end
 
+        sig do
+          params(
+            attached_class: T.nilable(Module),
+            method_name: Symbol,
+          ).returns(T.nilable(T::Boolean))
+        end
+        def method_new_in_abstract_class?(attached_class, method_name)
+          attached_class &&
+            method_name == :new &&
+            !!abstract_type_of(attached_class) &&
+            Class === attached_class.singleton_class
+        end
+
         sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
         def initialize_method_for(constant)
           constant.instance_method(:initialize)

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

@@ -16,12 +16,11 @@ module Tapioca
           constant = event.constant
           node = event.node
 
-          abstract_type = T::Private::Abstract::Data.get(constant, :abstract_type) ||
-            T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
+          abstract_type = abstract_type_of(constant)
 
           node << RBI::Helper.new(abstract_type.to_s) if abstract_type
-          node << RBI::Helper.new("final") if T::Private::Final.final_module?(constant)
-          node << RBI::Helper.new("sealed") if T::Private::Sealed.sealed_module?(constant)
+          node << RBI::Helper.new("final") if final_module?(constant)
+          node << RBI::Helper.new("sealed") if sealed_module?(constant)
         end
 
         sig { override.params(event: NodeAdded).returns(T::Boolean) }

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

@@ -31,14 +31,14 @@ module Tapioca
 
           # Map each type variable to its string representation.
           #
-          # Each entry of `type_variables` maps a Module to a String,
-          # and the order they are inserted into the hash is the order they should be
-          # defined in the source code.
-          type_variable_declarations = type_variables.map do |type_variable|
-            type_variable_name = type_variable.name
-            next unless type_variable_name
+          # Each entry of `type_variables` maps a Module to a String, or
+          # is a `has_attached_class!` declaration, and the order they are inserted
+          # into the hash is the order they should be defined in the source code.
+          type_variable_declarations = type_variables.filter_map do |type_variable|
+            node = node_from_type_variable(type_variable)
+            next unless node
 
-            tree << RBI::TypeMember.new(type_variable_name, type_variable.serialize)
+            tree << node
           end
 
           return if type_variable_declarations.empty?
@@ -46,6 +46,19 @@ module Tapioca
           tree << RBI::Extend.new("T::Generic")
         end
 
+        sig { params(type_variable: Tapioca::TypeVariableModule).returns(T.nilable(RBI::Node)) }
+        def node_from_type_variable(type_variable)
+          case type_variable.type
+          when Tapioca::TypeVariableModule::Type::HasAttachedClass
+            RBI::Send.new(type_variable.serialize)
+          else
+            type_variable_name = type_variable.name
+            return unless type_variable_name
+
+            RBI::TypeMember.new(type_variable_name, type_variable.serialize)
+          end
+        end
+
         sig { override.params(event: NodeAdded).returns(T::Boolean) }
         def ignore?(event)
           event.is_a?(Tapioca::Gem::ForeignScopeNodeAdded)

data/lib/tapioca/gem/pipeline.rb

@@ -304,9 +304,9 @@ module Tapioca
         @root << scope
       end
 
-      sig { params(constant: Class).returns(T.nilable(String)) }
+      sig { params(constant: T::Class[T.anything]).returns(T.nilable(String)) }
       def compile_superclass(constant)
-        superclass = T.let(nil, T.nilable(Class)) # rubocop:disable Lint/UselessAssignment
+        superclass = T.let(nil, T.nilable(T::Class[T.anything])) # rubocop:disable Lint/UselessAssignment
 
         while (superclass = superclass_of(constant))
           constant_name = name_of(constant)

data/lib/tapioca/gemfile.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "tapioca/bundler_ext/auto_require_hook"
+
 module Tapioca
   class Gemfile
     extend(T::Sig)
@@ -12,50 +14,6 @@ module Tapioca
       )
     end
 
-    # This is a module that gets prepended to `Bundler::Dependency` and
-    # makes sure even gems marked as `require: false` are required during
-    # `Bundler.require`.
-    module AutoRequireHook
-      extend T::Sig
-      extend T::Helpers
-
-      requires_ancestor { ::Bundler::Dependency }
-
-      @exclude = T.let([], T::Array[String])
-
-      class << self
-        extend T::Sig
-
-        sig { params(exclude: T::Array[String]).returns(T::Array[String]) }
-        attr_writer :exclude
-
-        sig { params(name: T.untyped).returns(T::Boolean) }
-        def excluded?(name)
-          @exclude.include?(name)
-        end
-      end
-
-      sig { returns(T.untyped).checked(:never) }
-      def autorequire
-        value = super
-
-        # If the gem is excluded, we don't want to force require it, in case
-        # it has side-effects users don't want. For example, `fakefs` gem, if
-        # loaded, takes over filesystem operations.
-        return value if AutoRequireHook.excluded?(name)
-
-        # If a gem is marked as `require: false`, then its `autorequire`
-        # value will be `[]`. But, we want those gems to be loaded for our
-        # purposes as well, so we return `nil` in those cases, instead, which
-        # means `require: true`.
-        return nil if value == []
-
-        value
-      end
-
-      ::Bundler::Dependency.prepend(self)
-    end
-
     sig { returns(Bundler::Definition) }
     attr_reader(:definition)
 
@@ -65,13 +23,15 @@ module Tapioca
     sig { returns(T::Array[String]) }
     attr_reader(:missing_specs)
 
-    sig { params(exclude: T::Array[String]).void }
-    def initialize(exclude)
-      AutoRequireHook.exclude = exclude
+    sig { params(excluded_gems: T::Array[String]).void }
+    def initialize(excluded_gems)
       @gemfile = T.let(File.new(Bundler.default_gemfile), File)
       @lockfile = T.let(File.new(Bundler.default_lockfile), File)
       @definition = T.let(Bundler::Dsl.evaluate(gemfile, lockfile, {}), Bundler::Definition)
+      @excluded_gems = excluded_gems
+
       dependencies, missing_specs = load_dependencies
+
       @dependencies = T.let(dependencies, T::Array[GemSpec])
       @missing_specs = T.let(missing_specs, T::Array[String])
     end
@@ -83,7 +43,9 @@ module Tapioca
 
     sig { void }
     def require_bundle
-      T.unsafe(runtime).require(*groups)
+      BundlerExt::AutoRequireHook.override_require_false(exclude: @excluded_gems) do
+        T.unsafe(runtime).require(*groups)
+      end
     end
 
     private

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -80,7 +80,7 @@ module Tapioca
         dsl_dir: String,
         auto_strictness: T::Boolean,
         gems: T::Array[Gemfile::GemSpec],
-        compilers: T::Enumerable[Class],
+        compilers: T::Enumerable[T.class_of(Dsl::Compiler)],
       ).void
     end
     def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: [], compilers: [])

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -25,6 +25,7 @@ module Tapioca
       {
         # 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
+        generic_class: ::Gem::Requirement.new(">= 0.5.10820"), # https://github.com/sorbet/sorbet/pull/6781
       }.freeze,
       T::Hash[Symbol, ::Gem::Requirement],
     )

data/lib/tapioca/internal.rb

@@ -30,6 +30,7 @@ require "tapioca/helpers/gem_helper"
 
 require "tapioca/helpers/sorbet_helper"
 require "tapioca/helpers/rbi_helper"
+require "tapioca/sorbet_ext/backcompat_patches"
 require "tapioca/sorbet_ext/fixed_hash_patch"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"

data/lib/tapioca/loaders/dsl.rb

@@ -9,9 +9,16 @@ module Tapioca
       class << self
         extend T::Sig
 
-        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, eager_load: eager_load, app_root: app_root)
+        sig do
+          params(tapioca_path: String, eager_load: T::Boolean, app_root: String, halt_upon_load_error: T::Boolean).void
+        end
+        def load_application(tapioca_path:, eager_load: true, app_root: ".", halt_upon_load_error: true)
+          loader = new(
+            tapioca_path: tapioca_path,
+            eager_load: eager_load,
+            app_root: app_root,
+            halt_upon_load_error: halt_upon_load_error,
+          )
           loader.load
         end
       end
@@ -25,13 +32,16 @@ module Tapioca
 
       protected
 
-      sig { params(tapioca_path: String, eager_load: T::Boolean, app_root: String).void }
-      def initialize(tapioca_path:, eager_load: true, app_root: ".")
+      sig do
+        params(tapioca_path: String, eager_load: T::Boolean, app_root: String, halt_upon_load_error: T::Boolean).void
+      end
+      def initialize(tapioca_path:, eager_load: true, app_root: ".", halt_upon_load_error: true)
         super()
 
         @tapioca_path = tapioca_path
         @eager_load = eager_load
         @app_root = app_root
+        @halt_upon_load_error = halt_upon_load_error
       end
 
       sig { void }
@@ -65,6 +75,7 @@ module Tapioca
           environment_load: true,
           eager_load: @eager_load,
           app_root: @app_root,
+          halt_upon_load_error: @halt_upon_load_error,
         )
 
         say("Done", :green)

data/lib/tapioca/loaders/gem.rb

@@ -15,14 +15,16 @@ module Tapioca
             prerequire: T.nilable(String),
             postrequire: String,
             default_command: String,
+            halt_upon_load_error: T::Boolean,
           ).void
         end
-        def load_application(bundle:, prerequire:, postrequire:, default_command:)
+        def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:)
           loader = new(
             bundle: bundle,
             prerequire: prerequire,
             postrequire: postrequire,
             default_command: default_command,
+            halt_upon_load_error: halt_upon_load_error,
           )
           loader.load
         end
@@ -41,22 +43,24 @@ module Tapioca
           prerequire: T.nilable(String),
           postrequire: String,
           default_command: String,
+          halt_upon_load_error: T::Boolean,
         ).void
       end
-      def initialize(bundle:, prerequire:, postrequire:, default_command:)
+      def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:)
         super()
 
         @bundle = bundle
         @prerequire = prerequire
         @postrequire = postrequire
         @default_command = default_command
+        @halt_upon_load_error = halt_upon_load_error
       end
 
       sig { void }
       def require_gem_file
         say("Requiring all gems to prepare for compiling... ")
         begin
-          load_bundle(@bundle, @prerequire, @postrequire)
+          load_bundle(@bundle, @prerequire, @postrequire, @halt_upon_load_error)
         rescue LoadError => e
           explain_failed_require(@postrequire, e)
           exit(1)

data/lib/tapioca/loaders/loader.rb

@@ -19,12 +19,17 @@ module Tapioca
       private
 
       sig do
-        params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void
+        params(
+          gemfile: Tapioca::Gemfile,
+          initialize_file: T.nilable(String),
+          require_file: T.nilable(String),
+          halt_upon_load_error: T::Boolean,
+        ).void
       end
-      def load_bundle(gemfile, initialize_file, require_file)
+      def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error)
         require_helper(initialize_file)
 
-        load_rails_application
+        load_rails_application(halt_upon_load_error: halt_upon_load_error)
 
         gemfile.require_bundle
 
@@ -33,8 +38,15 @@ module Tapioca
         load_rails_engines
       end
 
-      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: ".")
+      sig do
+        params(
+          environment_load: T::Boolean,
+          eager_load: T::Boolean,
+          app_root: String,
+          halt_upon_load_error: T::Boolean,
+        ).void
+      end
+      def load_rails_application(environment_load: false, eager_load: false, app_root: ".", halt_upon_load_error: true)
         return unless File.exist?("#{app_root}/config/application.rb")
 
         silence_deprecations
@@ -50,9 +62,13 @@ module Tapioca
         say(
           "\nTapioca 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}",
+            "generating RBIs. If your application does not use Rails and you wish to continue RBI generation " \
+            "please pass `--no-halt-upon-load-error` to the tapioca command in sorbet/tapioca/config.yml or in CLI." \
+            "\n#{e}",
           :yellow,
         )
+        raise e if halt_upon_load_error
+
         if e.backtrace
           backtrace = T.must(e.backtrace).join("\n")
           say(backtrace, :cyan) # TODO: Check verbose flag to print backtrace.

data/lib/tapioca/runtime/generic_type_registry.rb

@@ -151,7 +151,7 @@ module Tapioca
           generic_type
         end
 
-        sig { params(constant: Class).returns(Class) }
+        sig { params(constant: T::Class[T.anything]).returns(T::Class[T.anything]) }
         def create_safe_subclass(constant)
           # Lookup the "inherited" class method
           inherited_method = constant.method(:inherited)

data/lib/tapioca/runtime/reflection.rb

@@ -52,7 +52,7 @@ module Tapioca
         UNDEFINED_CONSTANT
       end
 
-      sig { params(object: BasicObject).returns(Class).checked(:never) }
+      sig { params(object: BasicObject).returns(T::Class[T.anything]).checked(:never) }
       def class_of(object)
         CLASS_METHOD.bind_call(object)
       end
@@ -68,7 +68,7 @@ module Tapioca
         name&.start_with?("#<") ? nil : name
       end
 
-      sig { params(constant: Module).returns(Class) }
+      sig { params(constant: Module).returns(T::Class[T.anything]) }
       def singleton_class_of(constant)
         SINGLETON_CLASS_METHOD.bind_call(constant)
       end
@@ -78,7 +78,7 @@ module Tapioca
         ANCESTORS_METHOD.bind_call(constant)
       end
 
-      sig { params(constant: Class).returns(T.nilable(Class)) }
+      sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) }
       def superclass_of(constant)
         SUPERCLASS_METHOD.bind_call(constant)
       end
@@ -113,7 +113,7 @@ module Tapioca
         if Class === constant
           ancestors_of(superclass_of(constant) || Object)
         else
-          Module.ancestors
+          Module.new.ancestors
         end
       end
 
@@ -161,7 +161,7 @@ module Tapioca
       #   descendants_of(C) # => [B, A, D]
       sig do
         type_parameters(:U)
-          .params(klass: T.all(Class, T.type_parameter(:U)))
+          .params(klass: T.all(T::Class[T.anything], T.type_parameter(:U)))
           .returns(T::Array[T.type_parameter(:U)])
       end
       def descendants_of(klass)
@@ -192,6 +192,22 @@ module Tapioca
         end.to_set
       end
 
+      sig { params(constant: Module).returns(T.untyped) }
+      def abstract_type_of(constant)
+        T::Private::Abstract::Data.get(constant, :abstract_type) ||
+          T::Private::Abstract::Data.get(singleton_class_of(constant), :abstract_type)
+      end
+
+      sig { params(constant: Module).returns(T::Boolean) }
+      def final_module?(constant)
+        T::Private::Final.final_module?(constant)
+      end
+
+      sig { params(constant: Module).returns(T::Boolean) }
+      def sealed_module?(constant)
+        T::Private::Sealed.sealed_module?(constant)
+      end
+
       private
 
       sig { params(constant: Module).returns(T::Array[UnboundMethod]) }

data/lib/tapioca/sorbet_ext/backcompat_patches.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+unless defined?(T.anything)
+  module T
+    class << self
+      def anything
+        T.untyped
+      end
+    end
+  end
+end
+
+unless defined?(T::Class)
+  module T
+    module Class
+      class << self
+        def [](type)
+          T.untyped
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -49,6 +49,21 @@ module T
           Tapioca::Runtime::GenericTypeRegistry.register_type_variable(self, type_variable)
         end
       end
+
+      def has_attached_class!(variance = :invariant, &bounds_proc)
+        Tapioca::Runtime::GenericTypeRegistry.register_type_variable(
+          self,
+          Tapioca::TypeVariableModule.new(
+            T.cast(self, Module),
+            Tapioca::TypeVariableModule::Type::HasAttachedClass,
+            variance,
+            nil,
+            nil,
+            nil,
+            bounds_proc,
+          ),
+        )
+      end
     end
 
     prepend TypeStoragePatch
@@ -140,9 +155,13 @@ module Tapioca
       enums do
         Member = new("type_member")
         Template = new("type_template")
+        HasAttachedClass = new("has_attached_class!")
       end
     end
 
+    sig { returns(Type) }
+    attr_reader :type
+
     # rubocop:disable Metrics/ParameterLists
     sig do
       params(

data/lib/tapioca/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.11.6
+  version: 0.11.7
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-12 00:00:00.000000000 Z
+date: 2023-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -149,6 +149,7 @@ files:
 - README.md
 - exe/tapioca
 - lib/tapioca.rb
+- lib/tapioca/bundler_ext/auto_require_hook.rb
 - lib/tapioca/cli.rb
 - lib/tapioca/commands.rb
 - lib/tapioca/commands/annotations.rb
@@ -253,6 +254,7 @@ files:
 - lib/tapioca/runtime/trackers/mixin.rb
 - lib/tapioca/runtime/trackers/required_ancestor.rb
 - lib/tapioca/runtime/trackers/tracker.rb
+- lib/tapioca/sorbet_ext/backcompat_patches.rb
 - lib/tapioca/sorbet_ext/fixed_hash_patch.rb
 - lib/tapioca/sorbet_ext/generic_name_patch.rb
 - lib/tapioca/sorbet_ext/name_patch.rb
@@ -281,7 +283,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.14
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard