Update DefinitionBuilder

Author: soutaro

lib/rbs/definition_builder.rb

@@ -151,6 +151,20 @@ def define_instance(definition, type_name, subst, define_class_vars:)
               end
             end
 
+          when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+            member.names.each do |name|
+              ivar_name = :"@#{name}"
+              attr_type = member.type || Types::Bases::Any.new(location: nil)
+              
+              insert_variable(
+                type_name,
+                definition.instance_variables,
+                name: ivar_name,
+                type: attr_type,
+                source: member
+              )
+            end
+
           when AST::Members::InstanceVariable
             insert_variable(
               type_name,
@@ -766,6 +780,59 @@ def define_method(methods, definition, method, subst, self_type_methods, defined
         )
 
         method_definition.annotations.replace(original.annotations)
+      when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [*duplicated_method.members, original]
+          )
+        end
+
+        attr_type = original.type || Types::Bases::Any.new(location: nil)
+        method_type =
+          if method.name.to_s.end_with?("=")
+            # setter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type).update(
+                required_positionals: [
+                  Types::Function::Param.new(type: attr_type, name: method.name.to_s.chomp("=").to_sym)
+                ]
+              ),
+              block: nil,
+              location: original.location
+            )
+          else
+            # getter
+            MethodType.new(
+              type_params: [],
+              type: Types::Function.empty(attr_type),
+              block: nil,
+              location: original.location
+            )
+          end
+
+        if implemented_in
+          super_method = existing_method
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: super_method,
+          defs: [
+            Definition::Method::TypeDef.new(
+              type: method_type,
+              member: original,
+              defined_in: defined_in,
+              implemented_in: implemented_in
+            )
+          ],
+          accessibility: method.accessibility,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace([])
       when AST::Ruby::Members::DefMember
         if duplicated_method = methods[method.name]
           raise DuplicatedMethodDefinitionError.new(

lib/rbs/definition_builder/method_builder.rb

@@ -149,6 +149,8 @@ def build_instance(type_name)
                         member: member,
                         accessibility: :public
                       )
+                    when AST::Ruby::Members::AttrReaderMember, AST::Ruby::Members::AttrWriterMember, AST::Ruby::Members::AttrAccessorMember
+                      build_ruby_attribute(methods, type, member: member, accessibility: :public)
                     end
                   end
                 end
@@ -227,6 +229,24 @@ def build_attribute(methods, type, member:, accessibility:)
         end
       end
 
+      def build_ruby_attribute(methods, type, member:, accessibility:)
+        member.names.each do |name|
+          if member.is_a?(AST::Ruby::Members::AttrReaderMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
+            defn = methods.methods[name] ||= Methods::Definition.empty(type: type, name: name)
+
+            defn.accessibilities << accessibility
+            defn.originals << member
+          end
+
+          if member.is_a?(AST::Ruby::Members::AttrWriterMember) || member.is_a?(AST::Ruby::Members::AttrAccessorMember)
+            defn = methods.methods[:"#{name}="] ||= Methods::Definition.empty(type: type, name: :"#{name}=")
+
+            defn.accessibilities << accessibility
+            defn.originals << member
+          end
+        end
+      end
+
       def build_method(methods, type, member:, accessibility:)
         defn = methods.methods[member.name] ||= Methods::Definition.empty(type: type, name: member.name)
 

lib/rbs/environment.rb

@@ -748,6 +748,33 @@ def resolve_ruby_member(resolver, member, context:)
           absolute_type_name(resolver, nil, member.module_name, context: context),
           resolved_annotation
         )
+      when AST::Ruby::Members::AttrReaderMember
+        resolved_type_annotation = member.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::AttrReaderMember.new(
+          member.buffer,
+          member.node,
+          member.name_nodes,
+          member.leading_comment,
+          resolved_type_annotation
+        )
+      when AST::Ruby::Members::AttrWriterMember
+        resolved_type_annotation = member.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::AttrWriterMember.new(
+          member.buffer,
+          member.node,
+          member.name_nodes,
+          member.leading_comment,
+          resolved_type_annotation
+        )
+      when AST::Ruby::Members::AttrAccessorMember
+        resolved_type_annotation = member.type_annotation&.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        AST::Ruby::Members::AttrAccessorMember.new(
+          member.buffer,
+          member.node,
+          member.name_nodes,
+          member.leading_comment,
+          resolved_type_annotation
+        )
       else
         raise "Unknown member type: #{member.class}"
       end

sig/definition.rbs

@@ -12,6 +12,9 @@ module RBS
                   | AST::Members::InstanceVariable
                   | AST::Members::ClassVariable
                   | AST::Members::ClassInstanceVariable
+                  | AST::Ruby::Members::AttrReaderMember
+                  | AST::Ruby::Members::AttrWriterMember
+                  | AST::Ruby::Members::AttrAccessorMember
       attr_reader source: source
 
       def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
@@ -21,7 +24,7 @@ module RBS
 
     class Method
       type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
-                         | AST::Ruby::Members::DefMember
+                         | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
 
       class TypeDef
         attr_reader type: MethodType

sig/method_builder.rbs

@@ -16,7 +16,7 @@ module RBS
         #
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
-                        | AST::Ruby::Members::DefMember
+                        | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
 
           type overloading_definition = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
 
@@ -77,6 +77,8 @@ module RBS
 
       def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
 
+      def build_ruby_attribute: (Methods, Methods::instance_type, member: AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember, accessibility: Definition::accessibility) -> void
+
       def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition | AST::Ruby::Members::DefMember, accessibility: Definition::accessibility) -> void
 
       def each_rbs_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void

test/rbs/definition_builder_test.rb

@@ -3308,4 +3308,101 @@ class A
       end
     end
   end
+
+  def test_ruby_attribute_members_untyped
+    SignatureManager.new do |manager|
+      manager.add_ruby_file("attributes.rb", <<~RUBY)
+        class AttributeTest
+          attr_reader :name
+          attr_writer :age
+          attr_accessor :email
+        end
+      RUBY
+
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_instance(type_name("::AttributeTest")).tap do |definition|
+          # Test attr_reader generates reader method
+          assert_method_definition definition.methods[:name], ["() -> untyped"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@name], "untyped"
+
+          # Test attr_writer generates writer method
+          assert_method_definition definition.methods[:age=], ["(untyped age) -> untyped"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@age], "untyped"
+
+          # Test attr_accessor generates both reader and writer methods
+          assert_method_definition definition.methods[:email], ["() -> untyped"], accessibility: :public
+          assert_method_definition definition.methods[:email=], ["(untyped email) -> untyped"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@email], "untyped"
+        end
+      end
+    end
+  end
+
+  def test_ruby_attribute_members_typed
+    SignatureManager.new do |manager|
+      manager.add_ruby_file("typed_attributes.rb", <<~RUBY)
+        class TypedAttributeTest
+          attr_reader :name #: String
+
+          attr_writer :age #: Integer
+
+          attr_accessor :email #: String
+        end
+      RUBY
+
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_instance(type_name("::TypedAttributeTest")).tap do |definition|
+          # Test typed attr_reader
+          assert_method_definition definition.methods[:name], ["() -> ::String"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@name], "::String"
+
+          # Test typed attr_writer
+          assert_method_definition definition.methods[:age=], ["(::Integer age) -> ::Integer"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@age], "::Integer"
+
+          # Test typed attr_accessor
+          assert_method_definition definition.methods[:email], ["() -> ::String"], accessibility: :public
+          assert_method_definition definition.methods[:email=], ["(::String email) -> ::String"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@email], "::String"
+        end
+      end
+    end
+  end
+
+
+  def test_ruby_attribute_members_multiple_names
+    SignatureManager.new do |manager|
+      manager.add_ruby_file("multiple_attributes.rb", <<~RUBY)
+        class MultipleAttributeTest
+          attr_reader :first_name, :last_name #: String
+
+          attr_accessor :x, :y #: Integer
+        end
+      RUBY
+
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_instance(type_name("::MultipleAttributeTest")).tap do |definition|
+          # Test multiple attr_reader names
+          assert_method_definition definition.methods[:first_name], ["() -> ::String"], accessibility: :public
+          assert_method_definition definition.methods[:last_name], ["() -> ::String"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@first_name], "::String"
+          assert_ivar_definition definition.instance_variables[:@last_name], "::String"
+
+          # Test multiple attr_accessor names
+          assert_method_definition definition.methods[:x], ["() -> ::Integer"], accessibility: :public
+          assert_method_definition definition.methods[:x=], ["(::Integer x) -> ::Integer"], accessibility: :public
+          assert_method_definition definition.methods[:y], ["() -> ::Integer"], accessibility: :public
+          assert_method_definition definition.methods[:y=], ["(::Integer y) -> ::Integer"], accessibility: :public
+          assert_ivar_definition definition.instance_variables[:@x], "::Integer"
+          assert_ivar_definition definition.instance_variables[:@y], "::Integer"
+        end
+      end
+    end
+  end
 end