From: "fxn (Xavier Noria) via ruby-core" <ruby-core@...>
Date: 2025-02-13T16:58:48+00:00
Subject: [ruby-core:120987] [Ruby master Misc#21035] Clarify or redefine Module#autoload? and Module#const_defined?

Issue #21035 has been updated by fxn (Xavier Noria).


> This case was in a circular require pattern, which is unrecommended, so that it was not considered worth discussing anything based on this case.

I don't think there is a circular require, because `m.rb` is not doing a require of `foo.rb`. Note that no autoload is being triggered.

I would understand that _if_ the autoload was later triggered after `m.rb` is loaded, then `Kernel#require` does nothing due to idempotency, and a `NameError` happens. But that is independent of the logic of the predicates about the autoload metadata.

I would also understand that `Module#autoload` or constant lookup has special logic to handle circularity.

But the predicates basically ask for metadata about the autoload that was just declared.

Regarding use cases:

1) In some logic while scanning the file system, Zeitwerk needs to know if a given constant is set, either exists for real or has an autoload, because in that case it should decline managing the corresponding file, and move on with the scanning. Due to this logic, I need to manually test and register those edge cases because the API is insufficient.

2) `Module#constants` is inconsistent with the predicates.

----------------------------------------
Misc #21035: Clarify or redefine Module#autoload? and Module#const_defined?
https://bugs.ruby-lang.org/issues/21035#change-111891

* Author: fxn (Xavier Noria)
* Status: Open
----------------------------------------
The documentation for `Module#autoload?` says:

> Returns filename to be loaded if name is registered as autoload in the namespace of mod or one of its ancestors.

As a user, if I declare an autoload, I expect this API:

```ruby
module M
  autoload :Foo, 'foo'

  constants            # => [:Foo]
  const_defined?(:Foo) # => true
  autoload?(:Foo)      # => 'foo'
end
```

That it is indeed how it generally works. Even if the autoload path does not exist. But there is an edge case.

While `constants` does include always `:Foo` as far as I can tell, the return value of `const_defined?` and `autoload?` depends on the stack of features being loaded: The autoload path is resolved and if seen to be in the stack of features being loaded, the predicates return `false` and `nil`, respectively. Do you think that is intuitive?

I find that logic totally unexpected. I just defined an autoload, therefore, I think it would be natural for `autoload?` to return what I just configured. Why should `const_defined?` return nothing but `true`? And why is it not consistent with `constants`?

To me, it would make more sense that in the previous example `const_defined?` returns `true`, and `autoload?` returns `foo` unconditionally (and instantly, nowadays it takes a relative long time due to the lookup).

Now, if the autoload is triggered in a lookup **then** I would expect `Kernel#require` logic to apply. But not when calling some simple predicates.

Please, note that the present behavior is not documented, so on paper the change would not be backwards incompatible.

If, on the other side, it is preferred to keep the behavior as it is, I guess it should be documented with precision (accounting for symlinks, relative paths in `$LOAD_PATH`, etc.)




-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/