Replace alias-path regex with parser-supplied AST info

The lazy resolver previously inspected RDoc::Constant#value with a regex
to guess whether the RHS looked like a constant path. Both parsers
already know this from the AST/token stream:

* The Prism parser distinguishes ConstantReadNode/ConstantPathNode
  values via constant_path_string in lib/rdoc/parser/prism_ruby.rb.
* The legacy ripper parser only builds rhs_name from :on_const and `::`
  tokens in lib/rdoc/parser/ripper_ruby.rb, so reaching
  create_module_alias already implies the RHS is a constant path.

Track that explicit knowledge on the constant via a new
RDoc::Constant#is_alias_for_path attribute and drop the regex from
#resolved_alias_target. The lazy resolver now activates only when the
parser actually saw a constant reference, which is more accurate than
the regex (no false positives on string-shaped values that happen to
match) and removes a one-off pattern that was duplicated work.

Tests:

* Each parser-level test that asserts a real class is preserved now
  also asserts that the would-be alias target (Bar, Bar::Foo) keeps its
  own methods and doesn't end up in someone else's #aliases.
* The unit-level update_aliases tests assert the same: the would-be
  target keeps its method list and aliases stay empty.

These positive assertions guard against a future regression where the
real class survives but the alias target is somehow corrupted or has
its aliases list mutated.

Author: claude

lib/rdoc/code_object/constant.rb

@@ -26,6 +26,16 @@ class RDoc::Constant < RDoc::CodeObject
 
   attr_accessor :visibility
 
+  ##
+  # The constant path the RHS names, when the RHS is a bare constant
+  # reference (e.g. +Foo = Bar+ or +Foo = Bar::Baz+). Set by the parser at
+  # parse time, when AST/token info is available, so the lazy resolver does
+  # not have to re-examine the textual #value to decide whether it could be a
+  # class/module reference. nil for any other RHS shape (literals, calls,
+  # expressions).
+
+  attr_accessor :is_alias_for_path
+
   ##
   # Creates a new constant with +name+, +value+ and +comment+
 
@@ -35,8 +45,9 @@ def initialize(name, value, comment)
     @name  = name
     @value = value
 
-    @is_alias_for = nil
-    @visibility   = :public
+    @is_alias_for      = nil
+    @is_alias_for_path = nil
+    @visibility        = :public
 
     self.comment = comment
   end
@@ -102,16 +113,17 @@ def is_alias_for
   end
 
   ##
-  # Returns the class/module this constant *would* alias if its #value names
-  # one in the current store, or nil. Used to support `Const = RHS` parsed
-  # before `class RHS;end` is defined in another file. Pure lookup; does not
-  # mutate state. Honors :nodoc: (returns nil if document_self is false). Note
-  # that module nesting information is lost, so constant lookup is inaccurate.
+  # Returns the class/module this constant *would* alias if #is_alias_for_path
+  # was set by the parser and that path resolves to a known class/module, or
+  # nil. Used to support `Const = RHS` parsed before `class RHS;end` is defined
+  # in another file. Pure lookup; does not mutate state. Honors :nodoc:
+  # (returns nil if document_self is false). Note that module nesting
+  # information is lost, so constant lookup is inaccurate.
 
   def resolved_alias_target
     return nil unless document_self
-    return nil unless value&.match?(/\A(::)?([A-Z][A-Za-z0-9_]*)(::[A-Z][A-Za-z0-9_]*)*\z/)
-    parent.find_module_named(value)
+    return nil unless @is_alias_for_path
+    parent.find_module_named(@is_alias_for_path)
   end
 
   def inspect # :nodoc:

lib/rdoc/parser/prism_ruby.rb

@@ -767,7 +767,7 @@ def find_or_create_constant_owner_name(constant_path)
 
   # Adds a constant
 
-  def add_constant(constant_name, rhs_name, start_line, end_line)
+  def add_constant(constant_name, rhs_name, start_line, end_line, alias_path: nil)
     comment, directives = consecutive_comment(start_line)
     handle_code_object_directives(@container, directives) if directives
     owner, name = find_or_create_constant_owner_name(constant_name)
@@ -776,19 +776,21 @@ def add_constant(constant_name, rhs_name, start_line, end_line)
     constant = RDoc::Constant.new(name, rhs_name, comment)
     constant.store = @store
     constant.line = start_line
+    constant.is_alias_for_path = alias_path
     record_location(constant)
     handle_modifier_directive(constant, start_line)
     handle_modifier_directive(constant, end_line)
     owner.add_constant(constant)
+    return unless alias_path
     mod =
-      if rhs_name =~ /^::/
-        @store.find_class_or_module(rhs_name)
+      if alias_path.start_with?('::')
+        @store.find_class_or_module(alias_path)
       else
-        full_name = resolve_constant_path(rhs_name)
+        full_name = resolve_constant_path(alias_path)
         @store.find_class_or_module(full_name)
       end
     if mod && constant.document_self
-      a = @container.add_module_alias(mod, rhs_name, constant, @top_level)
+      a = @container.add_module_alias(mod, alias_path, constant, @top_level)
       a.store = @store
       a.line = start_line
       record_location(a)
@@ -1056,23 +1058,27 @@ def visit_constant_path_write_node(node)
       path = constant_path_string(node.target)
       return unless path
 
+      alias_path = constant_path_string(node.value)
       @scanner.add_constant(
         path,
-        constant_path_string(node.value) || node.value.slice,
+        alias_path || node.value.slice,
         node.location.start_line,
-        node.location.end_line
+        node.location.end_line,
+        alias_path: alias_path
       )
       @scanner.skip_comments_until(node.location.end_line)
       # Do not traverse rhs not to document `A::B = Struct.new{def undocumentable_method; end}`
     end
 
     def visit_constant_write_node(node)
       @scanner.process_comments_until(node.location.start_line - 1)
+      alias_path = constant_path_string(node.value)
       @scanner.add_constant(
         node.name.to_s,
-        constant_path_string(node.value) || node.value.slice,
+        alias_path || node.value.slice,
         node.location.start_line,
-        node.location.end_line
+        node.location.end_line,
+        alias_path: alias_path
       )
       @scanner.skip_comments_until(node.location.end_line)
       # Do not traverse rhs not to document `A = Struct.new{def undocumentable_method; end}`

lib/rdoc/parser/ripper_ruby.rb

@@ -170,6 +170,7 @@ def create_attr(container, single, name, rw, comment) # :nodoc:
   # for "::") with the name from +constant+.
 
   def create_module_alias(container, constant, rhs_name) # :nodoc:
+    constant.is_alias_for_path = rhs_name
     mod = if rhs_name =~ /^::/ then
             @store.find_class_or_module rhs_name
           else

test/rdoc/code_object/class_module_test.rb

@@ -1468,8 +1468,10 @@ def test_update_aliases_does_not_overwrite_existing_class_with_same_name
     real_foo.add_method RDoc::AnyMethod.new(nil, 'real_method')
 
     other = top_level.add_class RDoc::NormalClass, 'Other'
+    other.add_method RDoc::AnyMethod.new(nil, 'other_method')
 
     const = RDoc::Constant.new 'Foo', 'Other', ''
+    const.is_alias_for_path = 'Other'
     const.record_location top_level
     object.add_constant const
 
@@ -1478,6 +1480,9 @@ def test_update_aliases_does_not_overwrite_existing_class_with_same_name
     assert_same real_foo, store.classes_hash['Foo']
     assert_nil store.classes_hash['Foo'].is_alias_for
     assert_equal ['real_method'], store.classes_hash['Foo'].method_list.map(&:name)
+    assert_same other, store.classes_hash['Other']
+    assert_nil other.is_alias_for
+    assert_equal ['other_method'], other.method_list.map(&:name)
     assert_empty other.aliases
   end
 
@@ -1487,8 +1492,10 @@ def test_update_aliases_skips_nodoc_constant
 
     object = top_level.add_class RDoc::NormalClass, 'Object'
     target = top_level.add_class RDoc::NormalClass, 'Target'
+    target.add_method RDoc::AnyMethod.new(nil, 'target_method')
 
     const = RDoc::Constant.new 'NodocAlias', 'Target', ''
+    const.is_alias_for_path = 'Target'
     const.record_location top_level
     const.document_self = nil
     object.add_constant const
@@ -1497,6 +1504,8 @@ def test_update_aliases_skips_nodoc_constant
 
     assert_nil store.classes_hash['NodocAlias']
     assert_nil store.modules_hash['NodocAlias']
+    assert_same target, store.classes_hash['Target']
+    assert_equal ['target_method'], target.method_list.map(&:name)
     assert_empty target.aliases
   end
 

test/rdoc/parser/prism_ruby_test.rb

@@ -1721,13 +1721,18 @@ def test_nodoc_constant_assignment_does_not_become_alias
     util_parser <<~RUBY
       class Outer
         class Bar
+          def bar_method; end
         end
         Foo = Bar # :nodoc:
       end
     RUBY
     @store.complete(:public)
     outer = @store.classes_hash['Outer']
     refute_nil outer
+    bar = outer.classes_hash['Bar']
+    refute_nil bar
+    assert_includes bar.method_list.map(&:name), 'bar_method'
+    assert_empty bar.aliases
     assert_nil outer.classes_hash['Foo']
     assert_nil outer.modules_hash['Foo']
     foo_const = outer.constants.find { |c| c.name == 'Foo' }
@@ -1752,6 +1757,11 @@ def other_method; end
     assert_nil foo.is_alias_for
     assert_includes foo.method_list.map(&:name), 'real_method'
     refute_includes foo.method_list.map(&:name), 'other_method'
+    bar = @store.classes_hash['Bar']
+    refute_nil bar
+    assert_nil bar.is_alias_for
+    assert_includes bar.method_list.map(&:name), 'other_method'
+    assert_empty bar.aliases
   end
 
   def test_nodoc_constant_assignment_preserves_real_class_with_same_name
@@ -1772,6 +1782,11 @@ def shim_method; end
     assert_nil foo.is_alias_for
     assert_includes foo.method_list.map(&:name), 'real_method'
     refute_includes foo.method_list.map(&:name), 'shim_method'
+    bar_foo = @store.classes_hash['Bar::Foo']
+    refute_nil bar_foo
+    assert_nil bar_foo.is_alias_for
+    assert_includes bar_foo.method_list.map(&:name), 'shim_method'
+    assert_empty bar_foo.aliases
   end
 
   def test_stopdoc_constant_assignment_preserves_real_class_with_same_name
@@ -1794,6 +1809,11 @@ def shim_method; end
     assert_nil foo.is_alias_for
     assert_includes foo.method_list.map(&:name), 'real_method'
     refute_includes foo.method_list.map(&:name), 'shim_method'
+    bar_foo = @store.classes_hash['Bar::Foo']
+    refute_nil bar_foo
+    assert_nil bar_foo.is_alias_for
+    assert_includes bar_foo.method_list.map(&:name), 'shim_method'
+    assert_empty bar_foo.aliases
   end
 
   def test_constant_with_singleton_class