WIP

Author: soutaro

lib/rbs/ast/ruby/members.rb

@@ -17,22 +17,30 @@ def initialize(buffer)
         class MethodTypeAnnotation
           class DocStyle
             attr_accessor :return_type_annotation
+            attr_reader :param_type_annotations
 
             def initialize
               @return_type_annotation = nil
+              @param_type_annotations = []
             end
 
             def map_type_name(&block)
               DocStyle.new.tap do |new|
                 new.return_type_annotation = return_type_annotation&.map_type_name(&block)
+                new.param_type_annotations.replace(
+                  param_type_annotations.map {|annot| annot.map_type_name(&block) }
+                )
               end #: self
             end
 
             def type_fingerprint
-              return_type_annotation&.type_fingerprint
+              [
+                return_type_annotation&.type_fingerprint,
+                param_type_annotations.map(&:type_fingerprint)
+              ]
             end
 
-            def method_type
+            def method_type(node)
               return_type =
                 case return_type_annotation
                 when Annotations::NodeTypeAssertion
@@ -43,12 +51,47 @@ def method_type
                   Types::Bases::Any.new(location: nil)
                 end
 
+              required_positionals = [] #: Array[Types::Function::Param]
+              required_keywords = {} #: Hash[Symbol, Types::Function::Param]
+
+              if node.parameters
+                params = node.parameters #: Prism::ParametersNode
+
+                params.requireds.each do |param|
+                  if param.is_a?(Prism::RequiredParameterNode)
+                    annotation = param_type_annotations.find { _1.name_location.source.to_sym == param.name }
+                    param_type = annotation&.param_type || Types::Bases::Any.new(location: nil)
+                    required_positionals << Types::Function::Param.new(type: param_type, name: nil)
+                  end
+                end
+
+                params.optionals.each do |param|
+                  if param.is_a?(Prism::OptionalParameterNode)
+                    annotation = param_type_annotations.find { _1.name_location.source.to_sym == param.name }
+                    param_type = annotation&.param_type || Types::Bases::Any.new(location: nil)
+                    required_keywords[param.name] = Types::Function::Param.new(type: param_type, name: nil)
+                  end
+                end
+
+                params.keywords.each do |param|
+                  if param.is_a?(Prism::RequiredKeywordParameterNode)
+                    annotation = param_type_annotations.find { _1.name_location.source.to_sym == param.name }
+                    param_type = annotation&.param_type || Types::Bases::Any.new(location: nil)
+                    required_keywords[param.name] = Types::Function::Param.new(type: param_type, name: nil)
+                  elsif param.is_a?(Prism::OptionalKeywordParameterNode)
+                    annotation = param_type_annotations.find { _1.name_location.source.to_sym == param.name }
+                    param_type = annotation&.param_type || Types::Bases::Any.new(location: nil)
+                    required_keywords[param.name] = Types::Function::Param.new(type: param_type, name: nil)
+                  end
+                end
+              end
+
               type = Types::Function.new(
-                required_positionals: [],
+                required_positionals: required_positionals,
                 optional_positionals: [],
                 rest_positionals: nil,
                 trailing_positionals: [],
-                required_keywords: {},
+                required_keywords: required_keywords,
                 optional_keywords: {},
                 rest_keywords: nil,
                 return_type: return_type
@@ -125,6 +168,15 @@ def self.build(leading_block, trailing_block, variables)
                       next
                     end
                   end
+                when Annotations::ParamTypeAnnotation
+                  unless type_annotations
+                    type_annotations = DocStyle.new()
+                  end
+
+                  if type_annotations.is_a?(DocStyle)
+                    type_annotations.param_type_annotations << paragraph
+                    next
+                  end
                 end
 
                 unused_annotations << paragraph
@@ -144,10 +196,10 @@ def empty?
             type_annotations.nil?
           end
 
-          def overloads
+          def overloads(node)
             case type_annotations
             when DocStyle
-              method_type = type_annotations.method_type
+              method_type = type_annotations.method_type(node)
 
               [
                 AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type)
@@ -224,7 +276,7 @@ def location
           end
 
           def overloads
-            method_type.overloads
+            method_type.overloads(node)
           end
 
           def overloading?

sig/ast/ruby/members.rbs

@@ -19,13 +19,17 @@ module RBS
 
         class MethodTypeAnnotation
           class DocStyle
+            type param_type_annotation = Annotations::ParamTypeAnnotation
+                                      
             attr_accessor return_type_annotation: Annotations::ReturnTypeAnnotation | Annotations::NodeTypeAssertion | nil
 
+            attr_reader param_type_annotations: Array[param_type_annotation]
+
             def initialize: () -> void
 
             def map_type_name: () { (TypeName) -> TypeName } -> self
 
-            def method_type: () -> MethodType
+            def method_type: (Prism::DefNode) -> MethodType
 
             def type_fingerprint: () -> untyped
           end
@@ -53,7 +57,7 @@ module RBS
 
           # Returns the method type overloads
           #
-          def overloads: () -> Array[AST::Members::MethodDefinition::Overload]
+          def overloads: (Prism::DefNode) -> Array[AST::Members::MethodDefinition::Overload]
 
           def overloading?: () -> bool
 

test/rbs/inline_parser_test.rb

@@ -275,6 +275,41 @@ def add(x, y)
     end
   end
 
+  def test_parse__def_method_docs
+    result = parse(<<~RUBY)
+      class Foo
+        # @rbs x: Integer
+        # @rbs y: Integer
+        # @rbs a: String
+        # @rbs b: String?
+        # @rbs return: String
+        def add(x, y = 3, a:, b: nil)
+        end
+      end
+    RUBY
+
+    assert_empty result.diagnostics
+
+    result.declarations[0].tap do |decl|
+      decl.members[0].tap do |member|
+        assert_instance_of RBS::AST::Ruby::Members::DefMember, member
+        assert_equal ["(Integer, y: Integer, a: String, b: String?) -> String"], member.overloads.map { _1.method_type.to_s }
+      end
+    end
+  end
+
+
+  def test_error__def_method_docs
+    result = parse(<<~RUBY)
+      class Foo
+        # @rbs x: Integer
+        # @rbs return: void
+        def add(y)
+        end
+      end
+    RUBY
+  end
+
   def test_parse__skip_class_module
     result = parse(<<~RUBY)
       # @rbs skip -- not a constant