From: sawadatsuyoshi@... Date: 2021-03-06T02:50:14+00:00 Subject: [ruby-core:102759] [Ruby master Bug#17354] Module#const_source_location is misleading for constants awaiting autoload Issue #17354 has been updated by sawa (Tsuyoshi Sawada). When I proposed this feature in #10771, the motivation was to create a tool that automatically reads ruby code and documents its methods and constants together with their source code. To extract the relevant source code, knowing the start and end points of the definitions is necessary. The current feature gives the file name and the line number of the start point of the definition, lacking the character position (as well as information regarding the endpoint of the definition), which is only a part of what as necessary for me, but I still appreciate the developers for implementing the feature. I agree with Tom that the current behaviour is wrong, and returning the calling site does not make sense, nor is it useful. But I don't think `[]` should be returned, for the reason Aaron discusses. I think `nil` should be returned. And I think that the behaviour should be in line with that of `const_defined?`. I am not a big fan of Aaron's proposal (to attempt) to load the constant on the spot, but that would be my second preference. It is at least better than the current behaviour. ---------------------------------------- Bug #17354: Module#const_source_location is misleading for constants awaiting autoload https://bugs.ruby-lang.org/issues/17354#change-90772 * Author: tomstuart (Tom Stuart) * Status: Open * Priority: Normal * ruby -v: ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin20] * Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN ---------------------------------------- Feature #10771 added `Module#const_source_location` as a way to find the source location of a constant���s definition. Bug #16764 reported that it didn���t work correctly for autoloaded constants, instead giving the source location of the `autoload` call site. This was fixed in `v3_0_0_preview1` in commit:92730810 and backported to `v2_7_2` in commit:c65aae11. However, `#const_source_location` still returns the `autoload` call site for constants which have not yet been loaded: ``` % echo 'class Foo; end' > foo.rb % irb >> Module.const_defined?(:Foo) => false >> Module.const_source_location(:Foo) => nil >> autoload :Foo, './foo' => nil >> Module.const_defined?(:Foo) => true >> Module.const_source_location(:Foo) => ["(irb)", 3] >> Module.const_get(:Foo) => Foo >> Module.const_defined?(:Foo) => true >> Module.const_source_location(:Foo) => ["./foo.rb", 1] ``` This edge case is undocumented and surprising. It looks like a bug to the programmer who receives the `autoload` location instead of one of the documented return values of `#const_source_location` (`nil`, `[]`, or the definition���s source location). We could either: * change the behaviour of `#const_source_location` to return `[]` for constants awaiting autoload, which is consistent with the [return value of `Module#const_defined?`](https://docs.ruby-lang.org/en/2.7.0/Module.html#method-i-const_defined-3F) in this case (���if the constant is not present but there is an autoload for it, `true` is returned directly���), as well as the [return value of `#const_source_location`](https://docs.ruby-lang.org/en/2.7.0/Module.html#method-i-const_source_location) for other constants whose source location is unknown (���if the constant is found, but its source location can not be extracted (constant is defined in C code), empty array is returned���); or * document the current behaviour of `#const_source_location` to make it less surprising. I recommend the first option ��� although the current behaviour was recently specified in source:spec/ruby/core/module/const_source_location_spec.rb@6d059674#L209, it doesn���t seem intentional ��� but if that���s not feasible, simply documenting this edge case would also be an improvement. -- https://bugs.ruby-lang.org/ Unsubscribe: