tapioca 0.19.1 → 0.20.0

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

@@ -80,7 +80,9 @@ module Tapioca
             signature = Runtime::Reflection.signature_of(method)
             return_type = signature&.return_type
 
-            valid_return_type?(return_type) ? return_type.to_s : "T.untyped"
+            # Wrap as non-nilable for required arguments. `coerce_input` supports both
+            # required and optional; optional arguments are re-wrapped below based on `type.non_null?`
+            valid_return_type?(return_type) ? (T::Utils.unwrap_nilable(return_type) || return_type).to_s : "T.untyped"
           when GraphQL::Schema::InputObject.singleton_class
             type_for_constant(unwrapped_type)
           when Module
@@ -89,15 +91,20 @@ module Tapioca
             "T.untyped"
           end
 
+          prepared = false
           if prepare_method
             prepare_signature = Runtime::Reflection.signature_of(prepare_method)
             prepare_return_type = prepare_signature&.return_type
             if valid_return_type?(prepare_return_type)
               parsed_type = prepare_return_type&.to_s
+              prepared = true
             end
           end
 
-          if type.list?
+          # A `prepare` method receives (and returns) the argument's fully coerced value, list
+          # wrapper included, so its return type already accounts for `type.list?` and must not be
+          # wrapped again.
+          if type.list? && !prepared
             parsed_type = "T::Array[#{parsed_type}]"
           end
 
@@ -112,7 +119,7 @@ module Tapioca
 
         #: (Module[top] constant) -> String
         def type_for_constant(constant)
-          if constant.instance_methods.include?(:prepare)
+          if constant.method_defined?(:prepare)
             prepare_method = constant.instance_method(:prepare)
 
             prepare_signature = Runtime::Reflection.signature_of(prepare_method)

data/lib/tapioca/dsl/pipeline.rb

@@ -64,6 +64,9 @@ module Tapioca
 
         # It's OK if there are no constants to process if we received a valid file/path.
         if constants_to_process.empty? && requested_paths.none? { |p| File.exist?(p) }
+          # When running within the add-on, return early so this expected case is not logged as an error
+          return [] if @lsp_addon
+
           report_error(<<~ERROR)
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
@@ -138,7 +141,7 @@ module Tapioca
         active_compilers.each do |compiler|
           constants.merge(compiler.processable_constants)
         end
-        constants = filter_anonymous_and_reloaded_constants(constants)
+        constants = filter_anonymous_constants(constants)
         constants -= skipped_constants
 
         unless requested_constants.empty? && requested_paths.empty?
@@ -154,32 +157,8 @@ module Tapioca
       end
 
       #: (Set[Module[top]] constants) -> Set[Module[top]]
-      def filter_anonymous_and_reloaded_constants(constants)
-        # Group constants by their names
-        constants_by_name = constants
-          .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[T::Module[T.anything]]])
-
-        # Find the constants that have been reloaded
-        reloaded_constants = constants_by_name.select { |_, constants| constants.size > 1 }.keys
-
-        unless reloaded_constants.empty? || @lsp_addon
-          reloaded_constant_names = reloaded_constants.map { |name| "`#{name}`" }.join(", ")
-
-          $stderr.puts("WARNING: Multiple constants with the same name: #{reloaded_constant_names}")
-          $stderr.puts("Make sure some object is not holding onto these constants during an app reload.")
-        end
-
-        # Look up all the constants back from their names. The resulting constant set will be the
-        # set of constants that are actually in memory with those names.
-        filtered_constants = constants_by_name
-          .keys
-          .map { |name| T.cast(Runtime::Reflection.constantize(name), T::Module[T.anything]) }
-          .select { |mod| Runtime::Reflection.constant_defined?(mod) }
-
-        Set.new.compare_by_identity.merge(filtered_constants)
+      def filter_anonymous_constants(constants)
+        constants.keep_if { |constant| Runtime::Reflection.name_of(constant) }
       end
 
       #: (Module[top] constant) -> RBI::File?

data/lib/tapioca/gem/events.rb

@@ -109,7 +109,7 @@ module Tapioca
       #|   untyped signature,
       #|   Array[[Symbol, String]] parameters
       #| ) -> void
-      def initialize(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
+      def initialize(symbol, constant, method, node, signature, parameters)
         super(symbol, constant)
         @node = node
         @method = method

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

@@ -15,7 +15,7 @@ module Tapioca
           "shareable_constant_value:",
           "rubocop:",
           "@requires_ancestor:",
-        ] #: Array[String]
+        ].freeze #: Array[String]
 
         #: (Pipeline pipeline, Rubydex::Graph gem_graph) -> void
         def initialize(pipeline, gem_graph)
@@ -69,13 +69,11 @@ module Tapioca
           end
           return [] unless declaration
 
-          comments = declaration.definitions.flat_map(&:comments)
-          comments.uniq!
-          return [] if comments.empty?
-
-          lines = comments
-            .map { |comment| comment.string.gsub(/^#+ ?/, "") }
-            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } || rbs_comment?(line) }
+          # Definitions often share a comment block, such as a license header, so de-duplicate them
+          lines = declaration.definitions
+            .map { |definition| comment_lines(definition) }
+            .uniq
+            .flatten
 
           # Strip leading and trailing blank lines, matching YARD's behavior
           lines = lines.reverse_each.drop_while(&:empty?).reverse_each.drop_while(&:empty?)
@@ -83,6 +81,13 @@ module Tapioca
           lines.map! { |line| RBI::Comment.new(line) }
         end
 
+        #: (Rubydex::Definition definition) -> Array[String]
+        def comment_lines(definition)
+          lines = definition.comments.map { |comment| comment.string.gsub(/^#+ ?/, "") }
+          lines.reject! { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } || rbs_comment?(line) }
+          lines
+        end
+
         # @override
         #: (NodeAdded event) -> bool
         def ignore?(event)

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

@@ -69,6 +69,7 @@ module Tapioca
 
           begin
             signature = signature_of!(method)
+            signature ||= inferred_attr_writer_signature(method, constant)
             method = signature.method if signature #: UnboundMethod
 
             case @pipeline.method_definition_in_gem(method.name, constant)
@@ -101,7 +102,7 @@ module Tapioca
           sanitized_parameters = parameters.each_with_index.map do |(type, name), index|
             fallback_arg_name = "_arg#{index}"
 
-            name = if name
+            sig_name = if name
               name.to_s
             else
               # For attr_writer methods, Sorbet signatures have the name
@@ -125,10 +126,14 @@ module Tapioca
               end
             end
 
-            # Sanitize param names
-            name = fallback_arg_name unless valid_parameter_name?(name)
+            # Sanitize param names, except for anonymous splat, keyword splat,
+            # and block parameters. Ruby reflects those as `:*`, `:**`, and `:&`,
+            # and Sorbet signatures use the same names to store their types.
+            is_anonymous_parameter = anonymous_parameter_name?(type, sig_name)
+            sig_name = fallback_arg_name unless is_anonymous_parameter || valid_parameter_name?(sig_name)
+            param_name = is_anonymous_parameter ? nil : sig_name
 
-            [type, name]
+            [type, param_name, sig_name]
           end
 
           rbi_method = RBI::Method.new(
@@ -137,26 +142,27 @@ module Tapioca
             visibility: visibility,
           )
 
-          sanitized_parameters.each do |type, name|
+          sanitized_parameters.each do |type, param_name, _sig_name|
             case type
             when :req
-              rbi_method << RBI::ReqParam.new(name)
+              rbi_method << RBI::ReqParam.new(param_name)
             when :opt
-              rbi_method << RBI::OptParam.new(name, "T.unsafe(nil)")
+              rbi_method << RBI::OptParam.new(param_name, "T.unsafe(nil)")
             when :rest
-              rbi_method << RBI::RestParam.new(name)
+              rbi_method << RBI::RestParam.new(param_name)
             when :keyreq
-              rbi_method << RBI::KwParam.new(name)
+              rbi_method << RBI::KwParam.new(param_name)
             when :key
-              rbi_method << RBI::KwOptParam.new(name, "T.unsafe(nil)")
+              rbi_method << RBI::KwOptParam.new(param_name, "T.unsafe(nil)")
             when :keyrest
-              rbi_method << RBI::KwRestParam.new(name)
+              rbi_method << RBI::KwRestParam.new(param_name)
             when :block
-              rbi_method << RBI::BlockParam.new(name)
+              rbi_method << RBI::BlockParam.new(param_name)
             end
           end
 
-          @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, sanitized_parameters)
+          parameters_for_signature = sanitized_parameters.map { |type, _param_name, sig_name| [type, sig_name] }
+          @pipeline.push_method(symbol_name, constant, method, rbi_method, signature, parameters_for_signature)
           tree << rbi_method
         end
 
@@ -192,6 +198,66 @@ module Tapioca
           }
         end
 
+        #: (UnboundMethod method, Module[top] constant) -> untyped
+        def inferred_attr_writer_signature(method, constant)
+          reader_method = attr_reader_for_writer(method, constant)
+          return unless reader_method
+
+          reader_signature = signature_of(reader_method)
+          return unless reader_signature
+
+          build_attr_writer_signature(method, reader_method, reader_signature)
+        end
+
+        #: (UnboundMethod method, Module[top] constant) -> UnboundMethod?
+        def attr_reader_for_writer(method, constant)
+          method_name = method.name.to_s
+          return unless method_name.end_with?("=")
+          return unless method.parameters == [[:req]]
+
+          reader_method = T.let(constant.instance_method(method_name.delete_suffix("=").to_sym), UnboundMethod)
+          reader_method = original_method(reader_method)
+          return unless same_source_location?(method, reader_method)
+          return unless method_owned_by_constant?(reader_method, constant)
+
+          reader_method
+        rescue NameError
+          nil
+        end
+
+        #: (UnboundMethod writer_method, UnboundMethod reader_method, untyped reader_signature) -> untyped
+        def build_attr_writer_signature(writer_method, reader_method, reader_signature)
+          return unless reader_signature.arg_types.empty?
+          return unless reader_signature.kwarg_types.empty?
+          return if reader_signature.rest_type
+          return if reader_signature.keyrest_type
+          return if reader_signature.block_type
+
+          T::Private::Methods::Signature.new(
+            method: writer_method,
+            method_name: writer_method.name,
+            raw_arg_types: { reader_method.name => reader_signature.return_type },
+            raw_return_type: reader_signature.return_type,
+            bind: nil,
+            mode: reader_signature.mode,
+            check_level: reader_signature.check_level,
+            on_failure: reader_signature.on_failure,
+            override_allow_incompatible: reader_signature.override_allow_incompatible,
+            defined_raw: reader_signature.defined_raw,
+          )
+        end
+
+        #: (UnboundMethod method) -> UnboundMethod
+        def original_method(method)
+          T.let(signature_of(method)&.method || method, UnboundMethod)
+        end
+
+        #: (UnboundMethod method, UnboundMethod other_method) -> bool
+        def same_source_location?(method, other_method)
+          source_location = method.source_location
+          !!source_location && source_location == other_method.source_location
+        end
+
         #: (Module[top] constant, String method_name) -> bool
         def struct_method?(constant, method_name)
           return false unless T::Props::ClassMethods === constant

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

@@ -11,7 +11,7 @@ module Tapioca
         #: (ScopeNodeAdded event) -> void
         def on_scope(event)
           constant = event.constant
-          return unless T::Enum > event.constant # rubocop:disable Style/InvertibleUnlessCondition
+          return unless T::Enum > event.constant
 
           enum_block = RBI::TEnumBlock.new
 

data/lib/tapioca/gem/pipeline.rb

@@ -7,7 +7,7 @@ module Tapioca
       include Runtime::Reflection
       include RBIHelper
 
-      IGNORED_SYMBOLS = ["YAML", "MiniTest", "Mutex"] #: Array[String]
+      IGNORED_SYMBOLS = ["YAML", "MiniTest", "Mutex"].freeze #: Array[String]
 
       #: Gemfile::GemSpec
       attr_reader :gem
@@ -100,7 +100,7 @@ module Tapioca
       #|   untyped signature,
       #|   Array[[Symbol, String]] parameters
       #| ) -> void
-      def push_method(symbol, constant, method, node, signature, parameters) # rubocop:disable Metrics/ParameterLists
+      def push_method(symbol, constant, method, node, signature, parameters)
         @events << Gem::MethodNodeAdded.new(symbol, constant, method, node, signature, parameters)
       end
 
@@ -356,7 +356,7 @@ module Tapioca
 
       #: (Class[top] constant) -> String?
       def compile_superclass(constant)
-        superclass = nil #: Class[top]? # rubocop:disable Lint/UselessAssignment
+        superclass = nil #: Class[top]?
 
         while (superclass = superclass_of(constant))
           constant_name = name_of(constant)

data/lib/tapioca/gemfile.rb

@@ -48,8 +48,21 @@ module Tapioca
       end
     end
 
+    #: (String path) -> bool
+    def excluded_gem_path?(path)
+      excluded_gem_specs.any? { |spec| spec.contains_path?(path) }
+    end
+
     private
 
+    #: -> Array[GemSpec]
+    def excluded_gem_specs
+      @excluded_gem_specs ||= @excluded_gems.filter_map do |name|
+        spec = ::Gem.loaded_specs[name]
+        GemSpec.new(spec) if spec
+      end #: Array[GemSpec]?
+    end
+
     #: File
     attr_reader(:gemfile, :lockfile)
 

data/lib/tapioca/helpers/env_helper.rb

@@ -5,7 +5,7 @@ module Tapioca
   # @requires_ancestor: Thor
   module EnvHelper
     #: (Hash[Symbol, untyped] options) -> void
-    def set_environment(options) # rubocop:disable Naming/AccessorMethodName
+    def set_environment(options)
       ENV["RAILS_ENV"] = ENV["RACK_ENV"] = options[:environment]
       ENV["RUBY_DEBUG_LAZY"] = "1"
     end

data/lib/tapioca/helpers/file_helper.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "open3"
+
+module Tapioca
+  module FileHelper
+    #: (Pathname filename, Pathname | String old_path, Pathname | String new_path) -> String?
+    def file_diff(filename, old_path, new_path)
+      filename = filename.to_s
+      stdout, stderr, status = Open3.capture3(
+        "diff",
+        "-u",
+        "--label=Current #{filename}",
+        old_path.to_s,
+        "--label=Expected #{filename} (After running `bin/tapioca dsl`)",
+        new_path.to_s,
+      )
+
+      unless [0, 1].include?(status.exitstatus)
+        error_msg("Failed to create #{filename} diff. #{stderr.chomp}")
+        return
+      end
+
+      stdout
+    rescue SystemCallError => e
+      error_msg("Failed to create #{filename} diff. #{e.message}")
+      nil
+    end
+
+    private
+
+    RED = "\e[31m" #: String
+    CLEAR = "\e[0m" #: String
+
+    #: (String message) -> void
+    def error_msg(message)
+      message = "#{RED}#{message}#{CLEAR}"
+      Kernel.warn(message)
+    end
+  end
+end

data/lib/tapioca/helpers/rbi_files_helper.rb

@@ -78,7 +78,7 @@ module Tapioca
       res = sorbet(
         "--no-config",
         "--error-url-base=#{error_url_base}",
-        "--stop-after namer",
+        "--stop-after resolver",
         dsl_dir,
         gem_dir,
       )
@@ -129,12 +129,16 @@ module Tapioca
         ERR
       end
 
-      if auto_strictness
-        redef_errors = errors.select { |error| error.code == 4010 }
-        update_gem_rbis_strictnesses(redef_errors, gem_dir)
-      end
+      handled_errors = apply_validation_fixes(errors, gem_dir: gem_dir, auto_strictness: auto_strictness)
 
       Kernel.raise Tapioca::Error, error_messages.join("\n") if parse_errors.any?
+
+      unhandled_errors = errors - handled_errors
+      unhandled_errors.reject! { |error| ignored_validation_error?(error, gem_dir: gem_dir, dsl_dir: dsl_dir) }
+
+      if unhandled_errors.empty?
+        say("  No errors found\n\n", [:green, :bold])
+      end
     end
 
     private
@@ -258,6 +262,93 @@ module Tapioca
       )
     end
 
+    SUPPRESS_PAYLOAD_SUPERCLASS_REDEFINITION_FLAG =
+      "--suppress-payload-superclass-redefinition-for" #: String
+
+    #: (Array[Spoom::Sorbet::Errors::Error] errors) -> void
+    def update_sorbet_config_for_payload_superclass_redefinitions(errors)
+      errors
+        .filter_map { |error| payload_superclass_constant_from_error(error) }
+        .uniq
+        .each { |constant| add_payload_superclass_suppression_to_config(constant) }
+    end
+
+    #: (Spoom::Sorbet::Errors::Error error) -> String?
+    def payload_superclass_constant_from_error(error)
+      error.more.each do |line|
+        if line =~ /--suppress-payload-superclass-redefinition-for=([^\s`]+)/
+          return T.must(Regexp.last_match(1))
+        end
+      end
+
+      nil
+    end
+
+    #: (
+    #|   Array[Spoom::Sorbet::Errors::Error] errors,
+    #|   gem_dir: String,
+    #|   auto_strictness: bool,
+    #| ) -> Array[Spoom::Sorbet::Errors::Error]
+    def apply_validation_fixes(errors, gem_dir:, auto_strictness:)
+      handled_errors = [] #: Array[Spoom::Sorbet::Errors::Error]
+
+      if auto_strictness
+        redef_errors = errors.select { |error| error.code == 4010 }
+        update_gem_rbis_strictnesses(redef_errors, gem_dir) if redef_errors.any?
+        handled_errors.concat(redef_errors)
+      end
+
+      # Automatically fix payload superclass redefinition errors.
+      payload_superclass_errors = errors.select { |error| payload_superclass_error?(error) }
+      if payload_superclass_errors.any?
+        update_sorbet_config_for_payload_superclass_redefinitions(payload_superclass_errors)
+      end
+      handled_errors.concat(payload_superclass_errors)
+
+      handled_errors
+    end
+
+    #: (Spoom::Sorbet::Errors::Error error) -> bool
+    def payload_superclass_error?(error)
+      error.more.any? { |line| line.include?(SUPPRESS_PAYLOAD_SUPERCLASS_REDEFINITION_FLAG) }
+    end
+
+    #: (Spoom::Sorbet::Errors::Error error, gem_dir: String, dsl_dir: String) -> bool
+    def ignored_validation_error?(error, gem_dir:, dsl_dir:)
+      return false if Dir.exist?(gem_dir) && !Dir.glob("#{gem_dir}/**/*.rbi").empty?
+
+      [5002, 5067].include?(error.code) && T.must(error.file).start_with?(dsl_dir)
+    end
+
+    #: (String constant) -> void
+    def add_payload_superclass_suppression_to_config(constant)
+      flag = "#{SUPPRESS_PAYLOAD_SUPERCLASS_REDEFINITION_FLAG}=#{constant}"
+      config_path = Tapioca::SORBET_CONFIG_FILE
+      config = File.exist?(config_path) ? File.read(config_path) : ""
+      flag_already_present = config.lines(chomp: true).include?(flag)
+
+      if flag_already_present
+        say(
+          "\n  Payload superclass of `#{constant}` was redefined; `#{flag}` is already in sorbet/config\n",
+          [:yellow, :bold],
+        )
+        return
+      end
+
+      FileUtils.mkdir_p(File.dirname(config_path))
+      if config.empty?
+        File.write(config_path, "#{flag}\n")
+      else
+        suffix = config.end_with?("\n") ? "" : "\n"
+        File.write(config_path, "#{config}#{suffix}#{flag}\n")
+      end
+      say(
+        "\n  Added `#{flag}` to sorbet/config (payload superclass of `#{constant}` was redefined)",
+        [:yellow, :bold],
+      )
+      say("\n")
+    end
+
     #: (Array[Spoom::Sorbet::Errors::Error] errors, String gem_dir) -> void
     def update_gem_rbis_strictnesses(errors, gem_dir)
       files = []

data/lib/tapioca/helpers/rbi_helper.rb

@@ -37,7 +37,7 @@ module Tapioca
       create_typed_param(RBI::OptParam.new(name, default), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String? name, type: String) -> RBI::TypedParam
     def create_rest_param(name, type:)
       create_typed_param(RBI::RestParam.new(name), type)
     end
@@ -52,12 +52,12 @@ module Tapioca
       create_typed_param(RBI::KwOptParam.new(name, default), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String? name, type: String) -> RBI::TypedParam
     def create_kw_rest_param(name, type:)
       create_typed_param(RBI::KwRestParam.new(name), type)
     end
 
-    #: (String name, type: String) -> RBI::TypedParam
+    #: (String? name, type: String) -> RBI::TypedParam
     def create_block_param(name, type:)
       create_typed_param(RBI::BlockParam.new(name), type)
     end
@@ -110,5 +110,19 @@ module Tapioca
     def valid_parameter_name?(name)
       Prism.parse_success?("def sentinel_method_name(#{name}:); end")
     end
+
+    #: (Symbol type, String name) -> bool
+    def anonymous_parameter_name?(type, name)
+      case type
+      when :rest
+        name == "*"
+      when :keyrest
+        name == "**"
+      when :block
+        name == "&"
+      else
+        false
+      end
+    end
   end
 end

data/lib/tapioca/helpers/sorbet_helper.rb

@@ -24,7 +24,7 @@ module Tapioca
 
     #: (String, rbi_mode: bool) { (String stderr) -> void } -> void
     def sorbet_syntax_check!(source, rbi_mode:, &on_failure)
-      quoted_source = "\"#{source}\""
+      quoted_source = source.shellescape
 
       result = if rbi_mode
         # --e-rbi cannot be used on its own, so we pass a dummy value like `-e ""`

data/lib/tapioca/internal.rb

@@ -12,6 +12,7 @@ require "tapioca/runtime/dynamic_mixin_compiler"
 require "tapioca/sorbet_ext/backcompat_patches"
 require "tapioca/sorbet_ext/name_patch"
 require "tapioca/sorbet_ext/generic_name_patch"
+require "tapioca/sorbet_ext/generic_type_patch"
 require "tapioca/sorbet_ext/proc_bind_patch"
 require "tapioca/sorbet_ext/void_patch"
 require "tapioca/runtime/generic_type_registry"
@@ -53,6 +54,7 @@ require "tapioca/helpers/rbi_helper"
 require "tapioca/helpers/package_url"
 require "tapioca/helpers/cli_helper"
 require "tapioca/helpers/config_helper"
+require "tapioca/helpers/file_helper"
 require "tapioca/helpers/rbi_files_helper"
 require "tapioca/helpers/env_helper"
 

data/lib/tapioca/loaders/gem.rb

@@ -49,6 +49,39 @@ module Tapioca
         @halt_upon_load_error = halt_upon_load_error
       end
 
+      #: -> void
+      def load_gem_extensions
+        say("Loading gem extension classes... ")
+
+        # Extensions are loaded before the bundle is required so that they can patch the gems
+        # they apply to as those gems are being loaded.
+        Dir.glob("#{Tapioca::TAPIOCA_DIR}/gem/extensions/**/*.rb").each do |extension|
+          require File.expand_path(extension)
+        end
+
+        ::Gem.find_files("tapioca/gem/extensions/*.rb").each do |extension|
+          next if @bundle.excluded_gem_path?(extension)
+
+          require File.expand_path(extension)
+        end
+
+        say("Done", :green)
+      end
+
+      #: (Tapioca::Gemfile gemfile, String? initialize_file, String? require_file, bool halt_upon_load_error) -> void
+      def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error)
+        require_helper(initialize_file)
+        load_gem_extensions
+
+        load_rails_application(halt_upon_load_error: halt_upon_load_error)
+
+        gemfile.require_bundle
+
+        require_helper(require_file)
+
+        load_rails_engines
+      end
+
       #: -> void
       def require_gem_file
         say("Requiring all gems to prepare for compiling... ")

data/lib/tapioca/loaders/loader.rb

@@ -15,19 +15,6 @@ module Tapioca
 
       private
 
-      #: (Tapioca::Gemfile gemfile, String? initialize_file, String? require_file, bool halt_upon_load_error) -> void
-      def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error)
-        require_helper(initialize_file)
-
-        load_rails_application(halt_upon_load_error: halt_upon_load_error)
-
-        gemfile.require_bundle
-
-        require_helper(require_file)
-
-        load_rails_engines
-      end
-
       #: (?environment_load: bool, ?eager_load: bool, ?app_root: String, ?halt_upon_load_error: bool) -> void
       def load_rails_application(environment_load: false, eager_load: false, app_root: ".", halt_upon_load_error: true)
         return unless File.exist?(File.expand_path("config/application.rb", app_root))