Implement inline parser with method type annotations

Author: soutaro

lib/rbs/ast/ruby/members.rb

@@ -83,35 +83,69 @@ def self.build(leading_block, trailing_block, variables)
           def empty?
             type_annotations.nil?
           end
+
+          def overloads
+            case type_annotations
+            when Annotations::NodeTypeAssertion
+              method_type = MethodType.new(
+                type_params: [],
+                type: Types::Function.empty(type_annotations.type),
+                block: nil,
+                location: nil
+              )
+
+              [
+                AST::Members::MethodDefinition::Overload.new(annotations: [], method_type: method_type)
+              ]
+            when Array
+              type_annotations.flat_map do |annotation|
+                case annotation
+                when Annotations::ColonMethodTypeAnnotation
+                  [
+                    AST::Members::MethodDefinition::Overload.new(
+                      annotations: annotation.annotations,
+                      method_type: annotation.method_type
+                    )
+                  ]
+                when Annotations::MethodTypesAnnotation
+                  annotation.overloads
+                end
+              end
+            when nil
+              method_type = MethodType.new(
+                type_params: [],
+                type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
+                block: nil,
+                location: nil
+              )
+
+              [
+                AST::Members::MethodDefinition::Overload.new(method_type: method_type, annotations: [])
+              ]
+            end
+          end
         end
 
         class DefMember < Base
           Overload = AST::Members::MethodDefinition::Overload
 
           attr_reader :name
           attr_reader :node
+          attr_reader :method_type
 
-          def initialize(buffer, name, node)
+          def initialize(buffer, name, node, method_type)
             super(buffer)
             @name = name
             @node = node
+            @method_type = method_type
           end
 
           def location
             rbs_location(node.location)
           end
 
           def overloads
-            method_type = MethodType.new(
-              type_params: [],
-              type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
-              block: nil,
-              location: nil
-            )
-
-            [
-              Overload.new(method_type: method_type, annotations: [])
-            ]
+            method_type.overloads
           end
 
           def overloading?

lib/rbs/environment.rb

@@ -673,7 +673,7 @@ def resolve_ruby_decl(resolver, decl, context:, prefix:)
             when AST::Ruby::Declarations::Base
               resolved.members << resolve_ruby_decl(resolver, member, context: inner_context, prefix: inner_prefix)
             when AST::Ruby::Members::Base
-              resolved.members << member
+              resolved.members << resolve_ruby_member(resolver, member, context: inner_context)
             else
               raise "Unknown member type: #{member.class}"
             end
@@ -701,6 +701,20 @@ def resolve_ruby_decl(resolver, decl, context:, prefix:)
       end
     end
 
+    def resolve_ruby_member(resolver, member, context:)
+      case member
+      when AST::Ruby::Members::DefMember
+        AST::Ruby::Members::DefMember.new(
+          member.buffer,
+          member.name,
+          member.node,
+          member.method_type.map_type_name {|name, _, _| absolute_type_name(resolver, nil, name, context: context) }
+        )
+      else
+        raise "Unknown member type: #{member.class}"
+      end
+    end
+
     def resolve_member(resolver, map, member, context:)
       case member
       when AST::Members::MethodDefinition
@@ -816,7 +830,7 @@ def resolve_type_params(resolver, map, params, context:)
     end
 
     def absolute_type_name(resolver, map, type_name, context:)
-      type_name = map.resolve(type_name)
+      type_name = map.resolve(type_name) if map
       resolver.resolve(type_name, context: context) || type_name
     end
 

lib/rbs/inline_parser.rb

@@ -27,6 +27,8 @@ def initialize(location, message)
       NonConstantClassName = _ = Class.new(Base)
       NonConstantModuleName = _ = Class.new(Base)
       TopLevelMethodDefinition = _ = Class.new(Base)
+      UnusedInlineAnnotation = _ = Class.new(Base)
+      AnnotationSyntaxError = _ = Class.new(Base)
     end
 
     def self.parse(buffer, prism)
@@ -38,14 +40,15 @@ def self.parse(buffer, prism)
     end
 
     class Parser < Prism::Visitor
-      attr_reader :module_nesting, :result
+      attr_reader :module_nesting, :result, :comments
 
       include AST::Ruby::Helpers::ConstantHelper
       include AST::Ruby::Helpers::LocationHelper
 
       def initialize(result)
         @result = result
         @module_nesting = []
+        @comments = CommentAssociation.build(result.buffer, result.prism_result)
       end
 
       def buffer
@@ -85,6 +88,10 @@ def visit_class_node(node)
         push_module_nesting(class_decl) do
           visit_child_nodes(node)
         end
+
+        comments.each_enclosed_block(node) do |block|
+          report_unused_block(block)
+        end
       end
 
       def visit_module_node(node)
@@ -101,6 +108,10 @@ def visit_module_node(node)
         push_module_nesting(module_decl) do
           visit_child_nodes(node)
         end
+
+        comments.each_enclosed_block(node) do |block|
+          report_unused_block(block)
+        end
       end
 
       def visit_def_node(node)
@@ -114,8 +125,24 @@ def visit_def_node(node)
 
         case current = current_module
         when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
-          defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node)
+          leading_block = comments.leading_block!(node)
+
+          if node.end_keyword_loc
+            # Not an end-less def
+            end_loc = node.rparen_loc || node.parameters&.location || node.name_loc
+            trailing_block = comments.trailing_block!(end_loc)
+          end
+
+          method_type, leading_unuseds, trailing_unused = AST::Ruby::Members::MethodTypeAnnotation.build(leading_block, trailing_block, [])
+          report_unused_annotation(trailing_unused, *leading_unuseds)
+
+          defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node, method_type)
           current.members << defn
+
+          # Skip other comments in `def` node
+          comments.each_enclosed_block(node) do |block|
+            comments.associated_blocks << block
+          end
         else
           diagnostics << Diagnostic::TopLevelMethodDefinition.new(
             rbs_location(node.name_loc),
@@ -131,6 +158,32 @@ def insert_declaration(decl)
           result.declarations << decl
         end
       end
+
+      def report_unused_annotation(*annotations)
+        annotations.each do |annotation|
+          case annotation
+          when AST::Ruby::CommentBlock::AnnotationSyntaxError
+            diagnostics << Diagnostic::AnnotationSyntaxError.new(
+              annotation.location, "Syntax error: " + annotation.error.error_message
+            )
+          when AST::Ruby::Annotations::Base
+            diagnostics << Diagnostic::UnusedInlineAnnotation.new(
+              annotation.location, "Unused inline rbs annotation"
+            )
+          end
+        end
+      end
+
+      def report_unused_block(block)
+        block.each_paragraph([]) do |paragraph|
+          case paragraph
+          when Location
+            # noop
+          else
+            report_unused_annotation(paragraph)
+          end
+        end
+      end
     end
   end
 end

sig/ast/ruby/members.rbs

@@ -33,15 +33,20 @@ module RBS
 
           # Returns `true` if it doesn't have any annotation
           def empty?: () -> bool
+
+          # Returns the method type overloads
+          #
+          def overloads: () -> Array[AST::Members::MethodDefinition::Overload]
         end
 
         class DefMember < Base
           class Overload = AST::Members::MethodDefinition::Overload
 
           attr_reader name: Symbol
           attr_reader node: Prism::DefNode
+          attr_reader method_type: MethodTypeAnnotation
 
-          def initialize: (Buffer, Symbol name, Prism::DefNode node) -> void
+          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation) -> void
 
           def location: () -> Location
 

sig/environment.rbs

@@ -216,8 +216,10 @@ module RBS
 
     def resolve_ruby_decl: (Resolver::TypeNameResolver, AST::Ruby::Declarations::t, context: Resolver::context, prefix: Namespace) -> AST::Ruby::Declarations::t
 
-    def absolute_type: (Resolver::TypeNameResolver, UseMap map, Types::t, context: Resolver::context) -> Types::t
+    def resolve_ruby_member: (Resolver::TypeNameResolver, AST::Ruby::Members::t, context: Resolver::context) -> AST::Ruby::Members::t
 
-    def absolute_type_name: (Resolver::TypeNameResolver, UseMap map, TypeName, context: Resolver::context) -> TypeName
+    def absolute_type: (Resolver::TypeNameResolver, UseMap? map, Types::t, context: Resolver::context) -> Types::t
+
+    def absolute_type_name: (Resolver::TypeNameResolver, UseMap? map, TypeName, context: Resolver::context) -> TypeName
   end
 end

sig/inline_parser.rbs

@@ -32,9 +32,16 @@ module RBS
       class TopLevelMethodDefinition < Base
       end
 
+      class UnusedInlineAnnotation < Base
+      end
+
+      class AnnotationSyntaxError < Base
+      end
+
       type t = NotImplementedYet
              | NonConstantClassName | NonConstantModuleName
              | TopLevelMethodDefinition
+             | UnusedInlineAnnotation | AnnotationSyntaxError
     end
 
     def self.parse: (Buffer, Prism::ParseResult) -> Result
@@ -46,6 +53,8 @@ module RBS
 
       include AST::Ruby::Helpers::LocationHelper
 
+      attr_reader comments: CommentAssociation
+
       attr_reader result: Result
 
       attr_reader module_nesting: Array[module_context]
@@ -63,6 +72,10 @@ module RBS
       def push_module_nesting: [T] (module_context) { () -> T } -> T
 
       def insert_declaration: (module_context) -> void
+
+      def report_unused_annotation: (*AST::Ruby::Annotations::t | nil | AST::Ruby::CommentBlock::AnnotationSyntaxError) -> void
+
+      def report_unused_block: (AST::Ruby::CommentBlock) -> void
     end
   end
 end

test/rbs/definition_builder_test.rb

@@ -3201,7 +3201,7 @@ module A
     end
   end
 
-  def test_inline_decl__class_def
+  def test_inline_decl__class_def__untyped
     SignatureManager.new do |manager|
       manager.add_ruby_file("inherited.rbs", <<~RUBY)
         class A
@@ -3226,4 +3226,31 @@ def hello(x) = 123
       end
     end
   end
+
+  def test_inline_decl__class_def__typed
+    SignatureManager.new do |manager|
+      manager.add_ruby_file("inherited.rbs", <<~RUBY)
+        class A
+          # @rbs (String) -> Integer
+          def hello(x) = 123
+        end
+      RUBY
+
+      manager.build do |env|
+        builder = DefinitionBuilder.new(env: env)
+
+        builder.build_instance(type_name("::A")).tap do |definition|
+          definition.methods[:hello].tap do |method|
+            assert_equal type_name("::A"), method.defined_in
+            assert_equal type_name("::A"), method.implemented_in
+
+            assert_equal [parse_method_type("(::String) -> ::Integer")], method.method_types
+            assert_equal [parse_method_type("(::String) -> ::Integer")], method.defs.map(&:type)
+
+            assert_equal [], method.annotations
+          end
+        end
+      end
+    end
+  end
 end