Use index from Context

Author: skatkov

lib/rdoc/code_object/context.rb

@@ -186,8 +186,8 @@ def add(klass, name, comment)
   def add_alias(an_alias)
     return an_alias unless @document_self
 
-    method_attr = find_method(an_alias.old_name, an_alias.singleton) ||
-                  find_attribute(an_alias.old_name, an_alias.singleton)
+    method_attr = find_method_from_hash(an_alias.old_name, an_alias.singleton) ||
+                  find_attribute_from_hash(an_alias.old_name, an_alias.singleton)
 
     if method_attr
       method_attr.add_alias an_alias, self
@@ -749,6 +749,14 @@ def find_attribute(name, singleton)
     @attributes.find { |a| a.name == name && a.singleton == singleton }
   end
 
+  def find_attribute_from_hash(name, singleton) # :nodoc:
+    name = name.delete_suffix('=')
+    key = "#{singleton ? '::' : '#'}#{name}"
+    attribute = @methods_hash[key]
+    attribute = @methods_hash["#{key}="] unless RDoc::Attr === attribute
+    attribute if RDoc::Attr === attribute && attribute.singleton == singleton
+  end
+
   ##
   # Finds an attribute with +name+ in this context
 
@@ -843,6 +851,12 @@ def find_method(name, singleton)
     }
   end
 
+  def find_method_from_hash(name, singleton) # :nodoc:
+    method = @methods_hash["#{singleton ? '::' : '#'}#{name}"]
+    # ponytail: keep the fallback until incremental rebuilds make this hash canonical.
+    RDoc::Attr === method ? find_method(name, singleton) : method
+  end
+
   ##
   # Finds a instance or module method with +name+ in this context
 

lib/rdoc/parser/rbs.rb

@@ -11,8 +11,6 @@ class RDoc::Parser::RBS < RDoc::Parser
   parse_files_matching RBS_FILE_EXTENSION
 
   def scan
-    @attributes_by_context = {}
-    @methods_by_context = {}
     _, _, decls = ::RBS::Parser.parse_signature(@content)
     decls.each do |decl|
       parse_decl decl, @top_level
@@ -92,28 +90,12 @@ def attr_rw_matches?(existing_rw, new_rw)
     existing_rw.each_char.any? { |rw| new_rw.include? rw }
   end
 
-  def attribute_index(context)
-    index = @attributes_by_context[context] ||= {}
-    context.attributes[index.length..].each do |attribute|
-      index[[attribute.name, attribute.singleton]] ||= attribute
-    end
-    index
-  end
-
-  def method_index(context)
-    index = @methods_by_context[context] ||= {}
-    context.method_list[index.length..].each do |method|
-      index[[method.name, !!method.singleton]] ||= method
-    end
-    index
-  end
-
   def merge_attribute_methods(context, name, rw, singleton, comment, type_signature_lines)
     method_names = []
     method_names << name if rw.include?('R')
     method_names << "#{name}=" if rw.include?('W')
 
-    methods = method_names.map { |method_name| method_index(context)[[method_name, singleton]] }
+    methods = method_names.map { |method_name| context.find_method_from_hash(method_name, singleton) }
     methods.compact.each do |method|
       merge_documentation method, comment, type_signature_lines
     end
@@ -153,7 +135,7 @@ def parse_attr_decl(decl, context)
     type_signature_lines = [decl.type.to_s]
     name = decl.name.to_s
     singleton = decl.kind == :singleton
-    if attribute = attribute_index(context)[[name, singleton]]
+    if attribute = context.find_attribute_from_hash(name, singleton)
       merge_documentation attribute, comment, type_signature_lines if
         attr_rw_matches? attribute.rw, rw
       return
@@ -263,7 +245,7 @@ def parse_method_decl(decl, context)
     singleton = rdoc_method_singleton?(decl)
     visibility = rdoc_method_visibility(decl)
 
-    if method = method_index(context)[[method_name, singleton]]
+    if method = context.find_method_from_hash(method_name, singleton)
       merge_documentation method, comment, type_signature_lines
       return
     end

test/rdoc/parser/rbs_test.rb

@@ -166,47 +166,25 @@ def name: () -> String
     assert_equal ['() -> String'], name.type_signature_lines
   end
 
-  def test_scan_indexes_forward_method_and_attribute_aliases
+  def test_scan_indexes_forward_attribute_alias
     util_parser(<<~RBS).scan
       class Sample
-        # Method alias docs.
-        alias salutation greet
         alias display_name name
 
-        def greet: () -> String
         # Base attribute docs.
         attr_reader name: String
 
-        # Dedicated method docs.
-        def salutation: () -> String
         # Dedicated attribute docs.
         attr_reader display_name: String
       end
     RBS
 
     sample = @store.find_class_named 'Sample'
-    salutation = sample.find_method 'salutation', false
     display_name = sample.find_attribute 'display_name', false
 
-    assert_equal "Method alias docs.\n---\nDedicated method docs.", salutation.comment.to_s.strip
     assert_equal "Base attribute docs.\n---\nDedicated attribute docs.", display_name.comment.to_s.strip
   end
 
-  def test_scan_treats_legacy_nil_singleton_as_instance_method
-    ruby_top_level = @store.add_file 'sample.rb'
-    sample = ruby_top_level.add_class RDoc::NormalClass, 'Sample'
-    greet = RDoc::AnyMethod.new 'greet', singleton: nil
-    sample.add_method greet
-
-    util_parser(<<~RBS).scan
-      class Sample
-        def greet: () -> String
-      end
-    RBS
-
-    assert_equal ['() -> String'], greet.type_signature_lines
-  end
-
   def test_scan_preserves_rbs_markdown_when_extending_method_documentation
     ruby_top_level = @store.add_file 'sample.rb'
     sample = ruby_top_level.add_class RDoc::NormalClass, 'Sample'

test/rdoc/parser/ruby_test.rb

@@ -2722,6 +2722,13 @@ def test_read_directive_linear_performance
     end
   end
 
+  def test_alias_lookup_linear_performance
+    assert_linear_performance([1, 10, 100]) do |factor|
+      methods = Array.new(factor * 100) { |i| "  def m#{i}; end\n  alias a#{i} m#{i}" }.join("\n")
+      util_parser "class C#{factor}\n#{methods}\nend\n"
+    end
+  end
+
   def test_code_object_token_stream
     util_parser <<~RUBY
       class Foo

test/rdoc/rdoc_context_test.rb

@@ -541,6 +541,16 @@ def test_find_attribute_named
     assert_equal 'RW', @c1.find_attribute_named('attr_accessor').rw
   end
 
+  def test_find_attribute_from_hash
+    singleton = RDoc::Attr.new 'singleton', 'R', nil, singleton: true
+    @context.add_attribute singleton
+
+    assert_same @c1.find_attribute_named('attr_reader'), @c1.find_attribute_from_hash('attr_reader', false)
+    assert_same @c1.find_attribute_named('attr_writer'), @c1.find_attribute_from_hash('attr_writer=', false)
+    assert_same singleton, @context.find_attribute_from_hash('singleton', true)
+    assert_nil @c1.find_attribute_from_hash('attr_reader', true)
+  end
+
   def test_find_class_method_named
     assert_nil @c1.find_class_method_named('none')
 
@@ -584,6 +594,16 @@ def test_find_method
     assert_equal @c2_b, loaded_c2.find_method('b', nil)
   end
 
+  def test_find_method_from_hash
+    instance = RDoc::AnyMethod.new 'instance', singleton: nil
+    @context.add_method instance
+
+    assert_same instance, @context.find_method_from_hash('instance', false)
+    assert_same instance, @context.find_method_from_hash('instance', nil)
+    assert_same @c1__m, @c1.find_method_from_hash('m', true)
+    assert_nil @c1.find_method_from_hash('attr', false)
+  end
+
   def test_find_method_named
     assert_equal true, @c1.find_method_named('m').singleton
   end