WIP: singleton method definition ast

ruby · soutaro · Jan 16, 2025 · Jan 16, 2025 · Jan 16, 2025 · Jan 16, 2025
commit bf124b5d9db7fc99efec02c778f45da65dc0879a
diff --git a/lib/rbs/ast/ruby/members.rb b/lib/rbs/ast/ruby/members.rb
@@ -153,6 +153,14 @@ def construct_method_type(parameters)
                 location: nil
               )
             end
+
+            def empty?
+              !return_type_annotation &&
+                param_type_annotations.empty? &&
+                !splat_type_annotation &&
+                !kwsplat_type_annotation &&
+                !block_type_annotation
+            end
           end
 
           attr_reader :type_annotations, :annotations, :override
@@ -274,6 +282,12 @@ def self.build(leading_block, trailing_block, variables)
               unused_trailing_annotation
             ]
           end
+
+          def empty?
+            annotations.empty? && override.nil? && (
+              type_annotations.nil? || type_annotations.empty?
+            )
+          end
         end
 
         class DefMember < Base
@@ -337,42 +351,63 @@ def name_location
         end
 
         class DefSingletonMember < Base
-          attr_reader :node
+          attr_reader :node, :name, :inline_annotations
 
-          def initialize(buffer, node)
+          def initialize(buffer, node, name:, inline_annotations:)
             super(buffer)
             @node = node
+            @name = name
+            @inline_annotations = inline_annotations
           end
 
           def overloads
-            [
-              Overload.new(
-                MethodType.new(
-                  type_params: [],
-                  type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
-                  block: nil,
-                  location: nil
-                ),
-                []
-              )
-            ]
-          end
-
-          def name
-            node.name
+            case inline_annotations.type_annotations
+            when DefAnnotations::DocStyleTypeAnnotations, nil
+              annots = inline_annotations.type_annotations || DefAnnotations::DocStyleTypeAnnotations.empty
+              method_type = annots.construct_method_type(node.parameters)
+              [
+                Overload.new(method_type, [])
+              ]
+            when Array
+              inline_annotations.type_annotations.flat_map do |annotation|
+                case annotation
+                when Annotation::ColonMethodTypeAnnotation
+                  [Overload.new(annotation.method_type.update(location: nil), annotation.annotations)]
+                when Annotation::MethodTypesAnnotation
+                  annotation.overloads.map do
+                    Overload.new(_1.method_type.update(location: nil), _1.annotations)
+                  end
+                end
+              end
+            end
           end
 
           def self?
             node.receiver.is_a?(Prism::SelfNode)
           end
 
+          def override?
+            inline_annotations.override ? true : false
+          end
+
           def annotations
-            []
+            inline_annotations.annotations.flat_map do |annotation|
+              annotation.annotations
+            end
           end
 
           def location
             buffer.rbs_location(node.location)
           end
+
+          def map_type_name(&block)
+            DefSingletonMember.new(
+              buffer,
+              node,
+              name: name,
+              inline_annotations: inline_annotations.map_type_name(&block)
+            ) #: self
+          end
         end
 
         class AliasMember < Base

diff --git a/lib/rbs/inline_parser.rb b/lib/rbs/inline_parser.rb
@@ -453,7 +453,7 @@ def visit_def_node(node)
           context.members << member
         when AST::Ruby::Declarations::ModuleDecl, AST::Ruby::Declarations::ClassDecl
           if node.receiver
-            member = AST::Ruby::Members::DefSingletonMember.new(buffer, node)
+            member = AST::Ruby::Members::DefSingletonMember.new(buffer, node, name: node.name, inline_annotations: annotations)
             if member.self?
               context.members << member
             end

diff --git a/sig/ast/ruby/members.rbs b/sig/ast/ruby/members.rbs
@@ -59,6 +59,8 @@ module RBS
             ) -> void
 
             def construct_method_type: (Prism::ParametersNode?) -> MethodType
+
+            def empty?: () -> bool
           end
 
           type type_annotations = DocStyleTypeAnnotations | Array[Annotation::ColonMethodTypeAnnotation | Annotation::MethodTypesAnnotation] | nil
@@ -86,6 +88,9 @@ module RBS
             Array[Annotation::leading_annotation | CommentBlock::AnnotationSyntaxError],
             Annotation::trailing_annotation | CommentBlock::AnnotationSyntaxError | nil
           ]
+
+          # Returns `true` if it doesn't have any annotation
+          def empty?: () -> bool
         end
 
         class DefMember < Base
@@ -121,20 +126,26 @@ module RBS
         class DefSingletonMember < Base
           attr_reader buffer: Buffer
 
+          attr_reader name: Symbol
+
           attr_reader node: Prism::DefNode
 
-          def initialize: (Buffer, Prism::DefNode) -> void
+          attr_reader inline_annotations: DefAnnotations
+
+          def initialize: (Buffer, Prism::DefNode, name: Symbol, inline_annotations: DefAnnotations) -> void
 
           def overloads: () -> Array[Overload]
 
-          def name: () -> Symbol
+          def override?: () -> bool
 
           # Returns true if the receiver is `self`
           def self?: () -> bool
 
           def annotations: () -> Array[AST::Annotation]
 
           def location: () -> Location
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
         end
 
         class AliasMember < Base