Merge pull request #2623 from ruby/inline-attributes

Inline RBS declaration for attributes (`attr_***`)

Author: soutaro

lib/rbs/ast/ruby/members.rb

@@ -248,6 +248,50 @@ class ExtendMember < MixinMember
 
         class PrependMember < MixinMember
         end
+
+        class AttributeMember < Base
+          attr_reader :node
+          attr_reader :name_nodes
+          attr_reader :type_annotation
+          attr_reader :leading_comment
+
+          def initialize(buffer, node, name_nodes, leading_comment, type_annotation)
+            super(buffer)
+            @node = node
+            @name_nodes = name_nodes
+            @leading_comment = leading_comment
+            @type_annotation = type_annotation
+          end
+
+          def names
+            name_nodes.map do |node|
+              node.unescaped.to_sym
+            end
+          end
+
+          def location
+            rbs_location(node.location)
+          end
+
+          def name_locations
+            name_nodes.map do |name_node|
+              rbs_location(name_node.location)
+            end
+          end
+
+          def type
+            type_annotation&.type
+          end
+        end
+
+        class AttrReaderMember < AttributeMember
+        end
+
+        class AttrWriterMember < AttributeMember
+        end
+
+        class AttrAccessorMember < AttributeMember
+        end
       end
     end
   end

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/diff.rb

@@ -104,7 +104,13 @@ def definition_method_to_s(key, kind, definition_method)
         detail_to_s = @detail ? "[#{definition_method.defined_in} #{definition_method.accessibility}] " : ""
         if definition_method.alias_of
           first_def = definition_method.alias_of.defs.first #: Definition::Method::TypeDef
-          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{first_def.member.name}"
+          member_name = case first_def.member
+                        when AST::Members::Base
+                          first_def.member.name
+                        else
+                          raise
+                        end
+          "#{detail_to_s}alias #{prefix}#{key} #{prefix}#{member_name}"
         else
           "#{detail_to_s}def #{prefix}#{key}: #{definition_method.method_types.join(" | ")}"
         end

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

lib/rbs/inline_parser.rb

@@ -27,10 +27,12 @@ def initialize(location, message)
       NonConstantClassName = _ = Class.new(Base)
       NonConstantModuleName = _ = Class.new(Base)
       TopLevelMethodDefinition = _ = Class.new(Base)
+      TopLevelAttributeDefinition = _ = Class.new(Base)
       UnusedInlineAnnotation = _ = Class.new(Base)
       AnnotationSyntaxError = _ = Class.new(Base)
       MixinMultipleArguments = _ = Class.new(Base)
       MixinNonConstantModule = _ = Class.new(Base)
+      AttributeNonSymbolName = _ = Class.new(Base)
     end
 
     def self.parse(buffer, prism)
@@ -171,7 +173,7 @@ def visit_def_node(node)
       end
 
       def visit_call_node(node)
-        return unless node.receiver.nil? # Only handle top-level calls like include, extend, prepend
+        return unless node.receiver.nil? # Only handle top-level calls like include, extend, prepend, attr_*
 
         case node.name
         when :include, :extend, :prepend
@@ -181,6 +183,19 @@ def visit_call_node(node)
           when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
             parse_mixin_call(node)
           end
+        when :attr_reader, :attr_writer, :attr_accessor
+          return if skip_node?(node)
+
+          case current = current_module
+          when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
+            parse_attribute_call(node)
+          when nil
+            # Top-level attribute definition
+            diagnostics << Diagnostic::TopLevelAttributeDefinition.new(
+              rbs_location(node.message_loc || node.location),
+              "Top-level attribute definition is not supported"
+            )
+          end
         else
           visit_child_nodes(node)
         end
@@ -244,6 +259,66 @@ def parse_mixin_call(node)
         current_module!.members << member
       end
 
+      def parse_attribute_call(node)
+        # Get the name nodes (arguments to attr_*)
+        unless node.arguments && !node.arguments.arguments.empty?
+          return # No arguments, nothing to do
+        end
+
+        name_nodes = [] #: Array[Prism::SymbolNode]
+        node.arguments.arguments.each do |arg|
+          case arg
+          when Prism::SymbolNode
+            name_nodes << arg
+          else
+            # Non-symbol argument, report error
+            diagnostics << Diagnostic::AttributeNonSymbolName.new(
+              rbs_location(arg.location),
+              "Attribute name must be a symbol"
+            )
+          end
+        end
+
+        return if name_nodes.empty?
+
+        # Look for leading comment block
+        leading_block = comments.leading_block!(node)
+
+        # Look for trailing type annotation (#: Type)
+        trailing_block = comments.trailing_block!(node.location)
+        type_annotation = nil
+
+        if trailing_block
+          case annotation = trailing_block.trailing_annotation([])
+          when AST::Ruby::Annotations::NodeTypeAssertion
+            type_annotation = annotation
+          when AST::Ruby::CommentBlock::AnnotationSyntaxError
+            diagnostics << Diagnostic::AnnotationSyntaxError.new(
+              annotation.location, "Syntax error: " + annotation.error.error_message
+            )
+          end
+        end
+
+        # Report unused leading annotations since @rbs annotations are not used for attributes
+        if leading_block
+          report_unused_block(leading_block)
+        end
+
+        # Create the appropriate member type
+        member = case node.name
+        when :attr_reader
+          AST::Ruby::Members::AttrReaderMember.new(buffer, node, name_nodes, leading_block, type_annotation)
+        when :attr_writer
+          AST::Ruby::Members::AttrWriterMember.new(buffer, node, name_nodes, leading_block, type_annotation)
+        when :attr_accessor
+          AST::Ruby::Members::AttrAccessorMember.new(buffer, node, name_nodes, leading_block, type_annotation)
+        else
+          raise "Unexpected attribute method: #{node.name}"
+        end
+
+        current_module!.members << member
+      end
+
       def insert_declaration(decl)
         if current_module
           current_module.members << decl

sig/ast/ruby/members.rbs

@@ -10,7 +10,9 @@ module RBS
           include Helpers::LocationHelper
         end
 
-        type t = DefMember | IncludeMember | ExtendMember | PrependMember
+        type t = DefMember
+               | IncludeMember | ExtendMember | PrependMember
+               | AttrReaderMember | AttrWriterMember | AttrAccessorMember
 
         class MethodTypeAnnotation
           class DocStyle
@@ -93,6 +95,35 @@ module RBS
 
         class PrependMember < MixinMember
         end
+
+        class AttributeMember < Base
+          attr_reader node: Prism::CallNode
+
+          attr_reader name_nodes: Array[Prism::SymbolNode]
+
+          attr_reader type_annotation: Annotations::NodeTypeAssertion?
+
+          attr_reader leading_comment: CommentBlock?
+
+          def initialize: (Buffer, Prism::CallNode, Array[Prism::SymbolNode] name_nodes, RBS::AST::Ruby::CommentBlock? leading_comment, Annotations::NodeTypeAssertion? type_annotation) -> void
+
+          def names: () -> Array[Symbol]
+
+          def location: () -> Location
+
+          def name_locations: () -> Array[Location]
+
+          def type: () -> Types::t?
+        end
+
+        class AttrReaderMember < AttributeMember
+        end
+
+        class AttrWriterMember < AttributeMember
+        end
+
+        class AttrAccessorMember < AttributeMember
+        end
       end
     end
   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