Delay loading Zeitwerk

railties/lib/rails.rb

@@ -12,7 +12,6 @@ require "active_support/core_ext/object/blank"
 
 require "rails/application"
 require "rails/version"
-require "rails/autoloaders"
 
 require "active_support/railtie"
 require "action_dispatch/railtie"
@@ -115,7 +114,7 @@ module Rails
     end
 
     def autoloaders
-      Autoloaders
+      application.autoloaders
     end
   end
 end

railties/lib/rails/application.rb

@@ -10,6 +10,7 @@ require "active_support/hash_with_indifferent_access"
 require "active_support/configuration_file"
 require "rails/engine"
 require "rails/secrets"
+require "rails/autoloaders"
 
 module Rails
   # An Engine with the responsibility of coordinating the whole boot process.
@@ -95,7 +96,7 @@ module Rails
 
     attr_accessor :assets, :sandbox
     alias_method :sandbox?, :sandbox
-    attr_reader :reloaders, :reloader, :executor
+    attr_reader :reloaders, :reloader, :executor, :autoloaders
 
     delegate :default_url_options, :default_url_options=, to: :routes
 
@@ -117,6 +118,8 @@ module Rails
       @reloader          = Class.new(ActiveSupport::Reloader)
       @reloader.executor = @executor
 
+      @autoloaders = Rails::Autoloaders.new
+
       # are these actually used?
       @initial_variable_values = initial_variable_values
       @block = block

railties/lib/rails/application/finisher.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
 require "active_support/core_ext/string/inflections"
 require "active_support/core_ext/array/conversions"
 require "active_support/descendants_tracker"

railties/lib/rails/autoloaders.rb

@@ -1,44 +1,48 @@
 # frozen_string_literal: true
 
-require "zeitwerk"
-
 module Rails
-  module Autoloaders # :nodoc:
+  class Autoloaders # :nodoc:
     require_relative "autoloaders/inflector"
 
-    class << self
+    include Enumerable
-      include Enumerable
 
-      def main
+    attr_reader :main, :once
-        @main ||= Zeitwerk::Loader.new.tap do |loader|
-          loader.tag = "rails.main"
-          loader.inflector = Inflector
-        end
-      end
 
-      def once
+    def initialize
-        @once ||= Zeitwerk::Loader.new.tap do |loader|
+      # This `require` delays loading the library on purpose.
-          loader.tag = "rails.once"
+      #
-          loader.inflector = Inflector
+      # In Rails 7.0.0, railties/lib/rails.rb loaded Zeitwerk as a side-effect,
-        end
+      # but a couple of edge cases related to Bundler and Bootsnap showed up.
-      end
+      # They had to do with order of decoration of `Kernel#require`, something
+      # the three of them do.
+      #
+      # Delaying this `require` up to this point is a convenient trade-off.
+      require "zeitwerk"
 
-      def each
+      @main = Zeitwerk::Loader.new
-        yield main
+      @main.tag = "rails.main"
-        yield once
+      @main.inflector = Inflector
-      end
 
-      def logger=(logger)
+      @once = Zeitwerk::Loader.new
-        each { |loader| loader.logger = logger }
+      @once.tag = "rails.once"
-      end
+      @once.inflector = Inflector
+    end
 
-      def log!
+    def each
-        each(&:log!)
+      yield main
-      end
+      yield once
+    end
 
-      def zeitwerk_enabled?
+    def logger=(logger)
-        true
+      each { |loader| loader.logger = logger }
-      end
+    end
+
+    def log!
+      each(&:log!)
+    end
+
+    def zeitwerk_enabled?
+      true
     end
   end
 end

railties/lib/rails/autoloaders/inflector.rb

@@ -2,20 +2,16 @@
 
 require "active_support/inflector"
 
-module Rails
+module Rails::Autoloaders::Inflector # :nodoc:
-  module Autoloaders
+  # Concurrent::Map is not needed. This is a private class, and overrides
-    module Inflector # :nodoc:
+  # must be defined while the application boots.
-      # Concurrent::Map is not needed. This is a private class, and overrides
+  @overrides = {}
-      # must be defined while the application boots.
-      @overrides = {}
 
-      def self.camelize(basename, _abspath)
+  def self.camelize(basename, _abspath)
-        @overrides[basename] || basename.camelize
+    @overrides[basename] || basename.camelize
-      end
+  end
 
-      def self.inflect(overrides)
+  def self.inflect(overrides)
-        @overrides.merge!(overrides)
+    @overrides.merge!(overrides)
-      end
-    end
   end
 end