Issue #21154 has been updated by mame (Yusuke Endoh). fxn (Xavier Noria) wrote in #note-30:
Correct, Zeitwerk only sets autoloads with absolute paths (that may contain symlinks).
Thank you. So, Zeitwerk is able to avoid the limitation clarified in this ticket, right?
In general, autoload with a relative path needs to resolve the path to absolute one. This resolution may be too costly to do for all autoload calls by default.
And that is what the predicate `autoload?` is doing, which is the origin of this ticket.
Please note that the performance of `Kernel#autoload?` is not considered important. The purpose of `autoload` is to speed up boot time by deferring `require`. One typical use case involves configuring many `autoload`s but exiting the program without actually triggering most of them. Therefore, the performance of `Kernel#autoload` is important. On the other hand, metaprogramming features like `Kernel#autoload?` are not expected to require high performance.
I don't even know if that is intentional or it is implementation leaking
The current behavior of `autoload?` and `const_defined?` is intentional. These methods return truthy values when the constant is considered available in the current context. ```ruby # main.rb autoload :Foo, "./foo.rb" # In the context between the autoload setup and the point when it is triggered, # the constant Foo is considered (virtually) available. # So autoload? and const_defined? return truthy values. p autoload?(:Foo) #=> "./foo.rb" p Object.const_defined?(:Foo) #=> true # Trigger the autoload Foo ``` ```ruby # foo.rb # In the context between triggering the autoload and the actual definition of the constant, # the constant Foo is not considered available. # So autoload? and const_defined? return falsy values. p autoload?(:Foo) #=> nil p Object.const_defined?(:Foo) #=> false module Foo end ``` To achieve this behavior, `Kernel#autoload?` checks whether the autoload for the corresponding constant has already been triggered. In the current implementation, this check is effectively done by seeing whether the associated `require` has been called or not. ---------------------------------------- Misc #21154: Document or change Module#autoload? https://bugs.ruby-lang.org/issues/21154#change-112756 * Author: fxn (Xavier Noria) * Status: Feedback * Assignee: mame (Yusuke Endoh) ---------------------------------------- The documentation of `Module#autoload?` says
Returns filename to be loaded if name is registered as autoload in the namespace of mod or one of its ancestors.
Cool, but in the following snippet ```ruby autoload :Foo, 'foo' autoload?(:Foo) ``` the second line could evaluate to `nil`, and this does not seem to agree. I just registered an autoload, therefore (according to the documentation) I should get "foo" back in line 2. I'd like to ask for clarification from the Ruby team: 1. Is the documentation complete? Should that second line always return "foo"? 2. If the answer is no, which is the logic missing in the docs? Thank you! -- https://bugs.ruby-lang.org/