Fix attribute registration in .rbs files

References #1583

Author: lsegal

CHANGELOG.md

@@ -1,5 +1,7 @@
 # main
 
+- Fix attribute registration in .rbs files (#1583)
+
 # [0.9.42] - April 16th, 2026
 
 [0.9.42]: https://github.com/lsegal/yard/compare/v0.9.41...v0.9.42

lib/yard/handlers/rbs/attribute_handler.rb

@@ -15,7 +15,9 @@ class YARD::Handlers::RBS::AttributeHandler < YARD::Handlers::RBS::Base
     case statement.type
     when :attr_reader
       register_reader(attr_name, yard_types, mscope)
+      register_existing_attribute_method(attr_name, "#{attr_name}=", :write, mscope)
     when :attr_writer
+      register_existing_attribute_method(attr_name, attr_name, :read, mscope)
       register_writer(attr_name, yard_types, mscope)
     when :attr_accessor
       register_reader(attr_name, yard_types, mscope)
@@ -26,18 +28,52 @@ class YARD::Handlers::RBS::AttributeHandler < YARD::Handlers::RBS::Base
   private
 
   def register_reader(name, types, scope)
-    obj = register MethodObject.new(namespace, name, scope)
-    if types && !obj.has_tag?(:return)
-      obj.add_tag YARD::Tags::Tag.new(:return, '', types)
-    end
+    obj = MethodObject.new(namespace, name, scope)
+    obj.source ||= "def #{name}\n  @#{name}\nend"
+    obj.signature ||= "def #{name}"
+    obj = register(obj)
+    obj.docstring = "Returns the value of attribute #{name}." if obj.docstring.blank?(false)
+    apply_tag_types(obj, :return, types)
+    namespace.attributes[obj.scope][name] ||= SymbolHash[:read => nil, :write => nil]
+    namespace.attributes[obj.scope][name][:read] = obj
     obj
   end
 
   def register_writer(name, types, scope)
-    obj = register MethodObject.new(namespace, "#{name}=", scope)
-    if types && !obj.has_tag?(:param)
-      obj.add_tag YARD::Tags::Tag.new(:param, '', types, "value")
-    end
+    obj = MethodObject.new(namespace, "#{name}=", scope)
+    obj.parameters = [['value', nil]]
+    obj.source ||= "def #{name}=(value)\n  @#{name} = value\nend"
+    obj.signature ||= "def #{name}=(value)"
+    obj = register(obj)
+    obj.docstring = "Sets the attribute #{name}\n@param value the value to set the attribute #{name} to." if obj.docstring.blank?(false)
+    apply_tag_types(obj, :param, types, "value")
+    namespace.attributes[obj.scope][name] ||= SymbolHash[:read => nil, :write => nil]
+    namespace.attributes[obj.scope][name][:write] = obj
     obj
   end
+
+  def register_existing_attribute_method(attr_name, meth_name, type, scope)
+    namespace.attributes[scope][attr_name] ||= SymbolHash[:read => nil, :write => nil]
+    return if namespace.attributes[scope][attr_name][type]
+
+    obj = namespace.children.find do |other|
+      other.name == meth_name.to_sym && other.scope == scope
+    end
+
+    namespace.attributes[scope][attr_name][type] = obj if obj
+  end
+
+  def apply_tag_types(obj, tag_name, types, tag_param_name = nil)
+    return unless types
+
+    tag = obj.tags(tag_name).find do |existing_tag|
+      existing_tag.name == tag_param_name
+    end
+
+    if tag
+      tag.types ||= types
+    else
+      obj.add_tag YARD::Tags::Tag.new(tag_name, '', types, tag_param_name)
+    end
+  end
 end

spec/handlers/rbs/attribute_handler_spec.rb

@@ -2,6 +2,30 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 RSpec.describe YARD::Handlers::RBS::AttributeHandler do
+  def parse_ruby(src)
+    YARD::Registry.clear
+    YARD.parse_string(src)
+  end
+
+  def attribute_snapshot(namespace_path, attr_name, scope = :instance)
+    namespace = Registry.at(namespace_path)
+    attribute = namespace.attributes[scope][attr_name]
+    read = attribute[:read]
+    write = attribute[:write]
+
+    {
+      :read_path => read && read.path,
+      :write_path => write && write.path,
+      :read_docstring => read ? read.docstring.to_s : nil,
+      :write_docstring => write ? write.docstring.to_s : nil,
+      :read_signature => read && read.signature,
+      :write_signature => write && write.signature,
+      :write_parameters => write && write.parameters,
+      :read_is_attribute => read && read.is_attribute?,
+      :write_is_attribute => write && write.is_attribute?
+    }
+  end
+
   it "registers a reader method for attr_reader" do
     parse_rbs <<-RBS
 class Foo
@@ -13,6 +37,29 @@ class Foo
     expect(obj.tag(:return).types).to eq ['String']
   end
 
+  it "registers attr_reader as a YARD attribute like Ruby parsing does" do
+    parse_rbs <<-RBS
+class Foo
+  attr_reader name: String
+end
+    RBS
+
+    rbs_snapshot = attribute_snapshot('Foo', :name)
+    reader = Registry.at('Foo#name')
+
+    expect(reader.attr_info[:read]).to eq reader
+    expect(reader.attr_info[:write]).to be_nil
+    expect(reader.is_attribute?).to be true
+
+    parse_ruby <<-RUBY
+class Foo
+  attr_reader :name
+end
+    RUBY
+
+    expect(attribute_snapshot('Foo', :name)).to eq rbs_snapshot
+  end
+
   it "registers a writer method for attr_writer" do
     parse_rbs <<-RBS
 class Foo
@@ -34,6 +81,32 @@ class Foo
     expect(Registry.at('Foo#age=')).to be_a(CodeObjects::MethodObject)
   end
 
+  it "registers class-side attr_accessor as a YARD attribute like Ruby parsing does" do
+    parse_rbs <<-RBS
+class Foo
+  attr_accessor self.count: Integer
+end
+    RBS
+
+    rbs_snapshot = attribute_snapshot('Foo', :count, :class)
+    reader = Registry.at('Foo.count')
+    writer = Registry.at('Foo.count=')
+
+    expect(reader.attr_info[:read]).to eq reader
+    expect(reader.attr_info[:write]).to eq writer
+    expect(writer.is_attribute?).to be true
+
+    parse_ruby <<-RUBY
+class Foo
+  class << self
+    attr_accessor :count
+  end
+end
+    RUBY
+
+    expect(attribute_snapshot('Foo', :count, :class)).to eq rbs_snapshot
+  end
+
   it "registers a class-side reader for attr_reader self.name" do
     parse_rbs <<-RBS
 class Foo
@@ -55,6 +128,19 @@ class Foo
     expect(Registry.at('Foo#name').docstring).to eq "The user's name."
   end
 
+  it "links an existing complementary method into attr_info" do
+    parse_rbs <<-RBS
+class Foo
+  def name: () -> String
+  attr_writer name: String
+end
+    RBS
+
+    writer = Registry.at('Foo#name=')
+    expect(writer.attr_info[:read]).to eq Registry.at('Foo#name')
+    expect(writer.attr_info[:write]).to eq writer
+  end
+
   it "handles nullable attribute type" do
     parse_rbs <<-RBS
 class Foo