zeitwerk 2.4.0 → 2.5.0.beta2

data/lib/zeitwerk/explicit_namespace.rb

@@ -14,24 +14,22 @@ module Zeitwerk
       # the file system, to the loader responsible for them.
       #
       # @private
-      # @return [{String => Zeitwerk::Loader}]
+      # @sig Hash[String, Zeitwerk::Loader]
       attr_reader :cpaths
 
       # @private
-      # @return [Mutex]
+      # @sig Mutex
       attr_reader :mutex
 
       # @private
-      # @return [TracePoint]
+      # @sig TracePoint
       attr_reader :tracer
 
       # Asserts `cpath` corresponds to an explicit namespace for which `loader`
       # is responsible.
       #
       # @private
-      # @param cpath [String]
-      # @param loader [Zeitwerk::Loader]
-      # @return [void]
+      # @sig (String, Zeitwerk::Loader) -> void
       def register(cpath, loader)
         mutex.synchronize do
           cpaths[cpath] = loader
@@ -42,27 +40,36 @@ module Zeitwerk
       end
 
       # @private
-      # @param loader [Zeitwerk::Loader]
-      # @return [void]
-      def unregister(loader)
+      # @sig (Zeitwerk::Loader) -> void
+      def unregister_loader(loader)
         cpaths.delete_if { |_cpath, l| l == loader }
         disable_tracer_if_unneeded
       end
 
+      private
+
+      # @sig () -> void
       def disable_tracer_if_unneeded
         mutex.synchronize do
           tracer.disable if cpaths.empty?
         end
       end
 
+      # @sig (TracePoint) -> void
       def tracepoint_class_callback(event)
         # If the class is a singleton class, we won't do anything with it so we
         # can bail out immediately. This is several orders of magnitude faster
         # than accessing its name.
         return if event.self.singleton_class?
 
-        # Note that it makes sense to compute the hash code unconditionally,
-        # because the trace point is disabled if cpaths is empty.
+        # It might be tempting to return if name.nil?, to avoid the computation
+        # of a hash code and delete call. But Ruby does not trigger the :class
+        # event on Class.new or Module.new, so that would incur in an extra call
+        # for nothing.
+        #
+        # On the other hand, if we were called, cpaths is not empty. Otherwise
+        # the tracer is disabled. So we do need to go ahead with the hash code
+        # computation and delete call.
         if loader = cpaths.delete(real_mod_name(event.self))
           loader.on_namespace_loaded(event.self)
           disable_tracer_if_unneeded

data/lib/zeitwerk/gem_inflector.rb

@@ -2,16 +2,14 @@
 
 module Zeitwerk
   class GemInflector < Inflector
-    # @param root_file [String]
+    # @sig (String) -> void
     def initialize(root_file)
       namespace     = File.basename(root_file, ".rb")
       lib_dir       = File.dirname(root_file)
       @version_file = File.join(lib_dir, namespace, "version.rb")
     end
 
-    # @param basename [String]
-    # @param abspath [String]
-    # @return [String]
+    # @sig (String, String) -> String
     def camelize(basename, abspath)
       abspath == @version_file ? "VERSION" : super
     end

data/lib/zeitwerk/inflector.rb

@@ -11,9 +11,7 @@ module Zeitwerk
     #
     # Takes into account hard-coded mappings configured with `inflect`.
     #
-    # @param basename [String]
-    # @param _abspath [String]
-    # @return [String]
+    # @sig (String, String) -> String
     def camelize(basename, _abspath)
       overrides[basename] || basename.split('_').each(&:capitalize!).join
     end
@@ -30,8 +28,7 @@ module Zeitwerk
     #   inflector.camelize("mysql_adapter", abspath)    # => "MySQLAdapter"
     #   inflector.camelize("users_controller", abspath) # => "UsersController"
     #
-    # @param inflections [{String => String}]
-    # @return [void]
+    # @sig (Hash[String, String]) -> void
     def inflect(inflections)
       overrides.merge!(inflections)
     end
@@ -41,7 +38,7 @@ module Zeitwerk
     # Hard-coded basename to constant name user maps that override the default
     # inflection logic.
     #
-    # @return [{String => String}]
+    # @sig () -> Hash[String, String]
     def overrides
       @overrides ||= {}
     end

data/lib/zeitwerk/kernel.rb

@@ -12,15 +12,15 @@ module Kernel
   # On the other hand, if you publish a new version of a gem that is now managed
   # by Zeitwerk, client code can reference directly your classes and modules and
   # should not require anything. But if someone has legacy require calls around,
-  # they will work as expected, and in a compatible way.
+  # they will work as expected, and in a compatible way. This feature is by now
+  # EXPERIMENTAL and UNDOCUMENTED.
   #
   # We cannot decorate with prepend + super because Kernel has already been
   # included in Object, and changes in ancestors don't get propagated into
   # already existing ancestor chains.
   alias_method :zeitwerk_original_require, :require
 
-  # @param path [String]
-  # @return [Boolean]
+  # @sig (String) -> true | false
   def require(path)
     if loader = Zeitwerk::Registry.loader_for(path)
       if path.end_with?(".rb")
@@ -29,13 +29,14 @@ module Kernel
         end
       else
         loader.on_dir_autoloaded(path)
+        true
       end
     else
       zeitwerk_original_require(path).tap do |required|
         if required
-          realpath = $LOADED_FEATURES.last
-          if loader = Zeitwerk::Registry.loader_for(realpath)
-            loader.on_file_autoloaded(realpath)
+          abspath = $LOADED_FEATURES.last
+          if loader = Zeitwerk::Registry.loader_for(abspath)
+            loader.on_file_autoloaded(abspath)
           end
         end
       end

data/lib/zeitwerk/loader.rb

@@ -5,78 +5,31 @@ require "securerandom"
 
 module Zeitwerk
   class Loader
+    require_relative "loader/helpers"
     require_relative "loader/callbacks"
-    include Callbacks
-    include RealModName
-
-    # @return [String]
-    attr_reader :tag
-
-    # @return [#camelize]
-    attr_accessor :inflector
-
-    # @return [#call, #debug, nil]
-    attr_accessor :logger
-
-    # Absolute paths of the root directories. Stored in a hash to preserve
-    # order, easily handle duplicates, and also be able to have a fast lookup,
-    # needed for detecting nested paths.
-    #
-    #   "/Users/fxn/blog/app/assets"   => true,
-    #   "/Users/fxn/blog/app/channels" => true,
-    #   ...
-    #
-    # This is a private collection maintained by the loader. The public
-    # interface for it is `push_dir` and `dirs`.
-    #
-    # @private
-    # @return [{String => true}]
-    attr_reader :root_dirs
+    require_relative "loader/config"
 
-    # Absolute paths of files or directories that have to be preloaded.
-    #
-    # @private
-    # @return [<String>]
-    attr_reader :preloads
-
-    # Absolute paths of files, directories, or glob patterns to be totally
-    # ignored.
-    #
-    # @private
-    # @return [Set<String>]
-    attr_reader :ignored_glob_patterns
+    include RealModName
+    include Callbacks
+    include Helpers
+    include Config
 
-    # The actual collection of absolute file and directory names at the time the
-    # ignored glob patterns were expanded. Computed on setup, and recomputed on
-    # reload.
+    # Keeps track of autoloads defined by the loader which have not been
+    # executed so far.
     #
-    # @private
-    # @return [Set<String>]
-    attr_reader :ignored_paths
-
-    # Absolute paths of directories or glob patterns to be collapsed.
+    # This metadata helps us implement a few things:
     #
-    # @private
-    # @return [Set<String>]
-    attr_reader :collapse_glob_patterns
-
-    # The actual collection of absolute directory names at the time the collapse
-    # glob patterns were expanded. Computed on setup, and recomputed on reload.
+    # 1. When autoloads are triggered, ensure they define the expected constant
+    #    and invoke user callbacks. If reloading is enabled, remember cref and
+    #    abspath for later unloading logic.
     #
-    # @private
-    # @return [Set<String>]
-    attr_reader :collapse_dirs
-
-    # Maps real absolute paths for which an autoload has been set ---and not
-    # executed--- to their corresponding parent class or module and constant
-    # name.
+    # 2. When unloading, remove autoloads that have not been executed.
     #
-    #   "/Users/fxn/blog/app/models/user.rb"          => [Object, :User],
-    #   "/Users/fxn/blog/app/models/hotel/pricing.rb" => [Hotel, :Pricing]
-    #   ...
+    # 3. Eager load with a recursive const_get, rather than a recursive require,
+    #    for consistency with lazy loading.
     #
     # @private
-    # @return [{String => (Module, Symbol)}]
+    # @sig Zeitwerk::Autoloads
     attr_reader :autoloads
 
     # We keep track of autoloaded directories to remove them from the registry
@@ -86,15 +39,15 @@ module Zeitwerk
     # to concurrency (see why in Zeitwerk::Loader::Callbacks#on_dir_autoloaded).
     #
     # @private
-    # @return [<String>]
+    # @sig Array[String]
     attr_reader :autoloaded_dirs
 
     # Stores metadata needed for unloading. Its entries look like this:
     #
     #   "Admin::Role" => [".../admin/role.rb", [Admin, :Role]]
     #
-    # The cpath as key helps implementing unloadable_cpath? The real file name
-    # is stored in order to be able to delete it from $LOADED_FEATURES, and the
+    # The cpath as key helps implementing unloadable_cpath? The file name is
+    # stored in order to be able to delete it from $LOADED_FEATURES, and the
     # pair [Module, Symbol] is used to remove_const the constant from the class
     # or module object.
     #
@@ -102,7 +55,7 @@ module Zeitwerk
     # or eager loaded. Otherwise, the collection remains empty.
     #
     # @private
-    # @return [{String => (String, (Module, Symbol))}]
+    # @sig Hash[String, [String, [Module, Symbol]]]
     attr_reader :to_unload
 
     # Maps constant paths of namespaces to arrays of corresponding directories.
@@ -120,156 +73,35 @@ module Zeitwerk
     # up the corresponding autoloads.
     #
     # @private
-    # @return [{String => <String>}]
+    # @sig Hash[String, Array[String]]
     attr_reader :lazy_subdirs
 
-    # Absolute paths of files or directories not to be eager loaded.
-    #
-    # @private
-    # @return [Set<String>]
-    attr_reader :eager_load_exclusions
-
     # @private
-    # @return [Mutex]
+    # @sig Mutex
     attr_reader :mutex
 
     # @private
-    # @return [Mutex]
+    # @sig Mutex
     attr_reader :mutex2
 
     def initialize
-      @initialized_at = Time.now
-
-      @tag       = SecureRandom.hex(3)
-      @inflector = Inflector.new
-      @logger    = self.class.default_logger
-
-      @root_dirs              = {}
-      @preloads               = []
-      @ignored_glob_patterns  = Set.new
-      @ignored_paths          = Set.new
-      @collapse_glob_patterns = Set.new
-      @collapse_dirs          = Set.new
-      @autoloads              = {}
-      @autoloaded_dirs        = []
-      @to_unload              = {}
-      @lazy_subdirs           = {}
-      @eager_load_exclusions  = Set.new
-
-      # TODO: find a better name for these mutexes.
-      @mutex        = Mutex.new
-      @mutex2       = Mutex.new
-      @setup        = false
-      @eager_loaded = false
-
-      @reloading_enabled = false
-
-      Registry.register_loader(self)
-    end
+      super
 
-    # Sets a tag for the loader, useful for logging.
-    #
-    # @param tag [#to_s]
-    # @return [void]
-    def tag=(tag)
-      @tag = tag.to_s
-    end
+      @autoloads       = Autoloads.new
+      @autoloaded_dirs = []
+      @to_unload       = {}
+      @lazy_subdirs    = Hash.new { |h, cpath| h[cpath] = [] }
+      @mutex           = Mutex.new
+      @mutex2          = Mutex.new
+      @setup           = false
+      @eager_loaded    = false
 
-    # Absolute paths of the root directories. This is a read-only collection,
-    # please push here via `push_dir`.
-    #
-    # @return [<String>]
-    def dirs
-      root_dirs.keys.freeze
-    end
-
-    # Pushes `path` to the list of root directories.
-    #
-    # Raises `Zeitwerk::Error` if `path` does not exist, or if another loader in
-    # the same process already manages that directory or one of its ascendants
-    # or descendants.
-    #
-    # @param path [<String, Pathname>]
-    # @param namespace [Class, Module]
-    # @raise [Zeitwerk::Error]
-    # @return [void]
-    def push_dir(path, namespace: Object)
-      # Note that Class < Module.
-      unless namespace.is_a?(Module)
-        raise Error, "#{namespace.inspect} is not a class or module object, should be"
-      end
-
-      abspath = File.expand_path(path)
-      if dir?(abspath)
-        raise_if_conflicting_directory(abspath)
-        root_dirs[abspath] = namespace
-      else
-        raise Error, "the root directory #{abspath} does not exist"
-      end
-    end
-
-    # You need to call this method before setup in order to be able to reload.
-    # There is no way to undo this, either you want to reload or you don't.
-    #
-    # @raise [Zeitwerk::Error]
-    # @return [void]
-    def enable_reloading
-      mutex.synchronize do
-        break if @reloading_enabled
-
-        if @setup
-          raise Error, "cannot enable reloading after setup"
-        else
-          @reloading_enabled = true
-        end
-      end
-    end
-
-    # @return [Boolean]
-    def reloading_enabled?
-      @reloading_enabled
-    end
-
-    # Files or directories to be preloaded instead of lazy loaded.
-    #
-    # @param paths [<String, Pathname, <String, Pathname>>]
-    # @return [void]
-    def preload(*paths)
-      mutex.synchronize do
-        expand_paths(paths).each do |abspath|
-          preloads << abspath
-          do_preload_abspath(abspath) if @setup
-        end
-      end
-    end
-
-    # Configure files, directories, or glob patterns to be totally ignored.
-    #
-    # @param paths [<String, Pathname, <String, Pathname>>]
-    # @return [void]
-    def ignore(*glob_patterns)
-      glob_patterns = expand_paths(glob_patterns)
-      mutex.synchronize do
-        ignored_glob_patterns.merge(glob_patterns)
-        ignored_paths.merge(expand_glob_patterns(glob_patterns))
-      end
-    end
-
-    # Configure directories or glob patterns to be collapsed.
-    #
-    # @param paths [<String, Pathname, <String, Pathname>>]
-    # @return [void]
-    def collapse(*glob_patterns)
-      glob_patterns = expand_paths(glob_patterns)
-      mutex.synchronize do
-        collapse_glob_patterns.merge(glob_patterns)
-        collapse_dirs.merge(expand_glob_patterns(glob_patterns))
-      end
+      Registry.register_loader(self)
     end
 
-    # Sets autoloads in the root namespace and preloads files, if any.
+    # Sets autoloads in the root namespace.
     #
-    # @return [void]
+    # @sig () -> void
     def setup
       mutex.synchronize do
         break if @setup
@@ -277,7 +109,6 @@ module Zeitwerk
         actual_root_dirs.each do |root_dir, namespace|
           set_autoloads_in_dir(root_dir, namespace)
         end
-        do_preload
 
         @setup = true
       end
@@ -290,8 +121,11 @@ module Zeitwerk
     # else, they are eligible for garbage collection, which would effectively
     # unload them.
     #
-    # @private
-    # @return [void]
+    # This method is public but undocumented. Main interface is `reload`, which
+    # means `unload` + `setup`. This one is avaiable to be used together with
+    # `unregister`, which is undocumented too.
+    #
+    # @sig () -> void
     def unload
       mutex.synchronize do
         # We are going to keep track of the files that were required by our
@@ -302,21 +136,26 @@ module Zeitwerk
         # is enough.
         unloaded_files = Set.new
 
-        autoloads.each do |realpath, (parent, cname)|
+        autoloads.each do |(parent, cname), abspath|
           if parent.autoload?(cname)
             unload_autoload(parent, cname)
           else
             # Could happen if loaded with require_relative. That is unsupported,
             # and the constant path would escape unloadable_cpath? This is just
             # defensive code to clean things up as much as we are able to.
-            unload_cref(parent, cname)   if cdef?(parent, cname)
-            unloaded_files.add(realpath) if ruby?(realpath)
+            unload_cref(parent, cname)  if cdef?(parent, cname)
+            unloaded_files.add(abspath) if ruby?(abspath)
           end
         end
 
-        to_unload.each_value do |(realpath, (parent, cname))|
-          unload_cref(parent, cname)   if cdef?(parent, cname)
-          unloaded_files.add(realpath) if ruby?(realpath)
+        to_unload.each do |cpath, (abspath, (parent, cname))|
+          unless on_unload_callbacks.empty?
+            value = parent.const_get(cname)
+            run_on_unload_callbacks(cpath, value, abspath)
+          end
+
+          unload_cref(parent, cname)  if cdef?(parent, cname)
+          unloaded_files.add(abspath) if ruby?(abspath)
         end
 
         unless unloaded_files.empty?
@@ -340,7 +179,7 @@ module Zeitwerk
         lazy_subdirs.clear
 
         Registry.on_unload(self)
-        ExplicitNamespace.unregister(self)
+        ExplicitNamespace.unregister_loader(self)
 
         @setup        = false
         @eager_loaded = false
@@ -354,7 +193,7 @@ module Zeitwerk
     # client code in the README of the project.
     #
     # @raise [Zeitwerk::Error]
-    # @return [void]
+    # @sig () -> void
     def reload
       if reloading_enabled?
         unload
@@ -371,32 +210,34 @@ module Zeitwerk
     # are not eager loaded. You can opt-out specifically in specific files and
     # directories with `do_not_eager_load`.
     #
-    # @return [void]
+    # @sig () -> void
     def eager_load
       mutex.synchronize do
         break if @eager_loaded
 
+        log("eager load start") if logger
+
         queue = []
         actual_root_dirs.each do |root_dir, namespace|
-          queue << [namespace, root_dir] unless eager_load_exclusions.member?(root_dir)
+          queue << [namespace, root_dir] unless excluded_from_eager_load?(root_dir)
         end
 
         while to_eager_load = queue.shift
           namespace, dir = to_eager_load
 
           ls(dir) do |basename, abspath|
-            next if eager_load_exclusions.member?(abspath)
+            next if excluded_from_eager_load?(abspath)
 
             if ruby?(abspath)
-              if cref = autoloads[File.realpath(abspath)]
-                cref[0].const_get(cref[1], false)
+              if cref = autoloads.cref_for(abspath)
+                cget(*cref)
               end
             elsif dir?(abspath) && !root_dirs.key?(abspath)
-              if collapse_dirs.member?(abspath)
+              if collapse?(abspath)
                 queue << [namespace, abspath]
               else
                 cname = inflector.camelize(basename, abspath)
-                queue << [namespace.const_get(cname, false), abspath]
+                queue << [cget(namespace, cname), abspath]
               end
             end
           end
@@ -408,23 +249,15 @@ module Zeitwerk
         autoloaded_dirs.clear
 
         @eager_loaded = true
-      end
-    end
 
-    # Let eager load ignore the given files or directories. The constants
-    # defined in those files are still autoloadable.
-    #
-    # @param paths [<String, Pathname, <String, Pathname>>]
-    # @return [void]
-    def do_not_eager_load(*paths)
-      mutex.synchronize { eager_load_exclusions.merge(expand_paths(paths)) }
+        log("eager load end") if logger
+      end
     end
 
     # Says if the given constant path would be unloaded on reload. This
     # predicate returns `false` if reloading is disabled.
     #
-    # @param cpath [String]
-    # @return [Boolean]
+    # @sig (String) -> bool
     def unloadable_cpath?(cpath)
       to_unload.key?(cpath)
     end
@@ -432,42 +265,28 @@ module Zeitwerk
     # Returns an array with the constant paths that would be unloaded on reload.
     # This predicate returns an empty array if reloading is disabled.
     #
-    # @return [<String>]
+    # @sig () -> Array[String]
     def unloadable_cpaths
       to_unload.keys.freeze
     end
 
-    # Logs to `$stdout`, handy shortcut for debugging.
+    # This is a dangerous method.
     #
-    # @return [void]
-    def log!
-      @logger = ->(msg) { puts msg }
-    end
-
-    # @private
-    # @param dir [String]
-    # @return [Boolean]
-    def manages?(dir)
-      dir = dir + "/"
-      ignored_paths.each do |ignored_path|
-        return false if dir.start_with?(ignored_path + "/")
-      end
-
-      root_dirs.each_key do |root_dir|
-        return true if root_dir.start_with?(dir) || dir.start_with?(root_dir + "/")
-      end
-
-      false
+    # @experimental
+    # @sig () -> void
+    def unregister
+      Registry.unregister_loader(self)
+      ExplicitNamespace.unregister_loader(self)
     end
 
     # --- Class methods ---------------------------------------------------------------------------
 
     class << self
-      # @return [#call, #debug, nil]
+      # @sig #call | #debug | nil
       attr_accessor :default_logger
 
       # @private
-      # @return [Mutex]
+      # @sig Mutex
       attr_accessor :mutex
 
       # This is a shortcut for
@@ -481,7 +300,7 @@ module Zeitwerk
       # except that this method returns the same object in subsequent calls from
       # the same file, in the unlikely case the gem wants to be able to reload.
       #
-      # @return [Zeitwerk::Loader]
+      # @sig () -> Zeitwerk::Loader
       def for_gem
         called_from = caller_locations(1, 1).first.path
         Registry.loader_for_gem(called_from)
@@ -489,7 +308,7 @@ module Zeitwerk
 
       # Broadcasts `eager_load` to all loaders.
       #
-      # @return [void]
+      # @sig () -> void
       def eager_load_all
         Registry.loaders.each(&:eager_load)
       end
@@ -497,7 +316,7 @@ module Zeitwerk
       # Returns an array with the absolute paths of the root directories of all
       # registered loaders. This is a read-only collection.
       #
-      # @return [<String>]
+      # @sig () -> Array[String]
       def all_dirs
         Registry.loaders.flat_map(&:dirs).freeze
       end
@@ -507,21 +326,12 @@ module Zeitwerk
 
     private # -------------------------------------------------------------------------------------
 
-    # @return [<String>]
-    def actual_root_dirs
-      root_dirs.reject do |root_dir, _namespace|
-        !dir?(root_dir) || ignored_paths.member?(root_dir)
-      end
-    end
-
-    # @param dir [String]
-    # @param parent [Module]
-    # @return [void]
+    # @sig (String, Module) -> void
     def set_autoloads_in_dir(dir, parent)
       ls(dir) do |basename, abspath|
         begin
           if ruby?(basename)
-            basename[-3..-1] = ''
+            basename.delete_suffix!(".rb")
             cname = inflector.camelize(basename, abspath).to_sym
             autoload_file(parent, cname, abspath)
           elsif dir?(abspath)
@@ -531,9 +341,9 @@ module Zeitwerk
             # To resolve the ambiguity file name -> constant path this introduces,
             # the `app/models/concerns` directory is totally ignored as a namespace,
             # it counts only as root. The guard checks that.
-            unless root_dirs.key?(abspath)
+            unless root_dir?(abspath)
               cname = inflector.camelize(basename, abspath).to_sym
-              if collapse_dirs.member?(abspath)
+              if collapse?(abspath)
                 set_autoloads_in_dir(abspath, parent)
               else
                 autoload_subdir(parent, cname, abspath)
@@ -559,35 +369,30 @@ module Zeitwerk
       end
     end
 
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @param subdir [String]
-    # @return [void]
+    # @sig (Module, Symbol, String) -> void
     def autoload_subdir(parent, cname, subdir)
-      if autoload_path = autoload_for?(parent, cname)
+      if autoload_path = autoloads.abspath_for(parent, cname)
         cpath = cpath(parent, cname)
         register_explicit_namespace(cpath) if ruby?(autoload_path)
         # We do not need to issue another autoload, the existing one is enough
         # no matter if it is for a file or a directory. Just remember the
         # subdirectory has to be visited if the namespace is used.
-        (lazy_subdirs[cpath] ||= []) << subdir
+        lazy_subdirs[cpath] << subdir
       elsif !cdef?(parent, cname)
         # First time we find this namespace, set an autoload for it.
-        (lazy_subdirs[cpath(parent, cname)] ||= []) << subdir
+        lazy_subdirs[cpath(parent, cname)] << subdir
         set_autoload(parent, cname, subdir)
       else
         # For whatever reason the constant that corresponds to this namespace has
         # already been defined, we have to recurse.
-        set_autoloads_in_dir(subdir, parent.const_get(cname))
+        log("the namespace #{cpath(parent, cname)} already exists, descending into #{subdir}") if logger
+        set_autoloads_in_dir(subdir, cget(parent, cname))
       end
     end
 
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @param file [String]
-    # @return [void]
+    # @sig (Module, Symbol, String) -> void
     def autoload_file(parent, cname, file)
-      if autoload_path = autoload_for?(parent, cname)
+      if autoload_path = strict_autoload_path(parent, cname) || Registry.inception?(cpath(parent, cname))
         # First autoload for a Ruby file wins, just ignore subsequent ones.
         if ruby?(autoload_path)
           log("file #{file} is ignored because #{autoload_path} has precedence") if logger
@@ -606,194 +411,46 @@ module Zeitwerk
       end
     end
 
-    # @param dir [String] directory that would have autovivified a module
-    # @param file [String] the file where the namespace is explicitly defined
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @return [void]
+    # `dir` is the directory that would have autovivified a namespace. `file` is
+    # the file where we've found the namespace is explicitly defined.
+    #
+    # @sig (dir: String, file: String, parent: Module, cname: Symbol) -> void
     def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:)
       autoloads.delete(dir)
       Registry.unregister_autoload(dir)
 
+      log("earlier autoload for #{cpath(parent, cname)} discarded, it is actually an explicit namespace defined in #{file}") if logger
+
       set_autoload(parent, cname, file)
       register_explicit_namespace(cpath(parent, cname))
     end
 
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @param abspath [String]
-    # @return [void]
+    # @sig (Module, Symbol, String) -> void
     def set_autoload(parent, cname, abspath)
-      # $LOADED_FEATURES stores real paths since Ruby 2.4.4. We set and save the
-      # real path to be able to delete it from $LOADED_FEATURES on unload, and to
-      # be able to do a lookup later in Kernel#require for manual require calls.
-      #
-      # We freeze realpath because that saves allocations in Module#autoload.
-      # See #125.
-      realpath = File.realpath(abspath).freeze
-      parent.autoload(cname, realpath)
+      autoloads.define(parent, cname, abspath)
+
       if logger
-        if ruby?(realpath)
-          log("autoload set for #{cpath(parent, cname)}, to be loaded from #{realpath}")
+        if ruby?(abspath)
+          log("autoload set for #{cpath(parent, cname)}, to be loaded from #{abspath}")
         else
-          log("autoload set for #{cpath(parent, cname)}, to be autovivified from #{realpath}")
+          log("autoload set for #{cpath(parent, cname)}, to be autovivified from #{abspath}")
         end
       end
 
-      autoloads[realpath] = [parent, cname]
-      Registry.register_autoload(self, realpath)
+      Registry.register_autoload(self, abspath)
 
       # See why in the documentation of Zeitwerk::Registry.inceptions.
       unless parent.autoload?(cname)
-        Registry.register_inception(cpath(parent, cname), realpath, self)
-      end
-    end
-
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @return [String, nil]
-    def autoload_for?(parent, cname)
-      strict_autoload_path(parent, cname) || Registry.inception?(cpath(parent, cname))
-    end
-
-    # The autoload? predicate takes into account the ancestor chain of the
-    # receiver, like const_defined? and other methods in the constants API do.
-    #
-    # For example, given
-    #
-    #   class A
-    #     autoload :X, "x.rb"
-    #   end
-    #
-    #   class B < A
-    #   end
-    #
-    # B.autoload?(:X) returns "x.rb".
-    #
-    # We need a way to strictly check in parent ignoring ancestors.
-    #
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @return [String, nil]
-    if method(:autoload?).arity == 1
-      def strict_autoload_path(parent, cname)
-        parent.autoload?(cname) if cdef?(parent, cname)
-      end
-    else
-      def strict_autoload_path(parent, cname)
-        parent.autoload?(cname, false)
-      end
-    end
-
-    # This method is called this way because I prefer `preload` to be the method
-    # name to configure preloads in the public interface.
-    #
-    # @return [void]
-    def do_preload
-      preloads.each do |abspath|
-        do_preload_abspath(abspath)
-      end
-    end
-
-    # @param abspath [String]
-    # @return [void]
-    def do_preload_abspath(abspath)
-      if ruby?(abspath)
-        do_preload_file(abspath)
-      elsif dir?(abspath)
-        do_preload_dir(abspath)
-      end
-    end
-
-    # @param dir [String]
-    # @return [void]
-    def do_preload_dir(dir)
-      ls(dir) do |_basename, abspath|
-        do_preload_abspath(abspath)
-      end
-    end
-
-    # @param file [String]
-    # @return [Boolean]
-    def do_preload_file(file)
-      log("preloading #{file}") if logger
-      require file
-    end
-
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @return [String]
-    def cpath(parent, cname)
-      parent.equal?(Object) ? cname.to_s : "#{real_mod_name(parent)}::#{cname}"
-    end
-
-    # @param dir [String]
-    # @yieldparam path [String, String]
-    # @return [void]
-    def ls(dir)
-      Dir.foreach(dir) do |basename|
-        next if basename.start_with?(".")
-
-        abspath = File.join(dir, basename)
-        next if ignored_paths.member?(abspath)
-
-        # We freeze abspath because that saves allocations when passed later to
-        # File methods. See #125.
-        yield basename, abspath.freeze
+        Registry.register_inception(cpath(parent, cname), abspath, self)
       end
     end
 
-    # @param path [String]
-    # @return [Boolean]
-    def ruby?(path)
-      path.end_with?(".rb")
-    end
-
-    # @param path [String]
-    # @return [Boolean]
-    def dir?(path)
-      File.directory?(path)
-    end
-
-    # @param paths [<String, Pathname, <String, Pathname>>]
-    # @return [<String>]
-    def expand_paths(paths)
-      paths.flatten.map! { |path| File.expand_path(path) }
-    end
-
-    # @param glob_patterns [<String>]
-    # @return [<String>]
-    def expand_glob_patterns(glob_patterns)
-      # Note that Dir.glob works with regular file names just fine. That is,
-      # glob patterns technically need no wildcards.
-      glob_patterns.flat_map { |glob_pattern| Dir.glob(glob_pattern) }
-    end
-
-    # @return [void]
-    def recompute_ignored_paths
-      ignored_paths.replace(expand_glob_patterns(ignored_glob_patterns))
-    end
-
-    # @return [void]
-    def recompute_collapse_dirs
-      collapse_dirs.replace(expand_glob_patterns(collapse_glob_patterns))
-    end
-
-    # @param message [String]
-    # @return [void]
-    def log(message)
-      method_name = logger.respond_to?(:debug) ? :debug : :call
-      logger.send(method_name, "Zeitwerk@#{tag}: #{message}")
-    end
-
-    def cdef?(parent, cname)
-      parent.const_defined?(cname, false)
-    end
-
+    # @sig (String) -> void
     def register_explicit_namespace(cpath)
       ExplicitNamespace.register(cpath, self)
     end
 
+    # @sig (String) -> void
     def raise_if_conflicting_directory(dir)
       self.class.mutex.synchronize do
         Registry.loaders.each do |loader|
@@ -808,19 +465,22 @@ module Zeitwerk
       end
     end
 
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @return [void]
+    # @sig (String, Object, String) -> void
+    def run_on_unload_callbacks(cpath, value, abspath)
+      # Order matters. If present, run the most specific one.
+      on_unload_callbacks[cpath]&.each { |c| c.call(value, abspath) }
+      on_unload_callbacks[:ANY]&.each { |c| c.call(cpath, value, abspath) }
+    end
+
+    # @sig (Module, Symbol) -> void
     def unload_autoload(parent, cname)
-      parent.send(:remove_const, cname)
+      parent.__send__(:remove_const, cname)
       log("autoload for #{cpath(parent, cname)} removed") if logger
     end
 
-    # @param parent [Module]
-    # @param cname [Symbol]
-    # @return [void]
+    # @sig (Module, Symbol) -> void
     def unload_cref(parent, cname)
-      parent.send(:remove_const, cname)
+      parent.__send__(:remove_const, cname)
       log("#{cpath(parent, cname)} unloaded") if logger
     end
   end