Implement parser

Author: soutaro

lib/rbs/inline_parser.rb

@@ -29,6 +29,8 @@ def initialize(location, message)
       TopLevelMethodDefinition = _ = Class.new(Base)
       UnusedInlineAnnotation = _ = Class.new(Base)
       AnnotationSyntaxError = _ = Class.new(Base)
+      MixinMultipleArguments = _ = Class.new(Base)
+      MixinNonConstantModule = _ = Class.new(Base)
     end
 
     def self.parse(buffer, prism)
@@ -168,6 +170,80 @@ def visit_def_node(node)
         end
       end
 
+      def visit_call_node(node)
+        return unless node.receiver.nil? # Only handle top-level calls like include, extend, prepend
+
+        case node.name
+        when :include, :extend, :prepend
+          return if skip_node?(node)
+
+          case current = current_module
+          when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
+            parse_mixin_call(node)
+          end
+        else
+          visit_child_nodes(node)
+        end
+      end
+
+      private
+
+      def parse_mixin_call(node)
+        # Check for multiple arguments
+        if node.arguments && node.arguments.arguments.length > 1
+          diagnostics << Diagnostic::MixinMultipleArguments.new(
+            rbs_location(node.location),
+            "Mixing multiple modules with one call is not supported"
+          )
+          return
+        end
+
+        # Check for missing arguments
+        unless node.arguments && node.arguments.arguments.length == 1
+          # This shouldn't happen in valid Ruby code, but handle it gracefully
+          return
+        end
+
+        first_arg = node.arguments.arguments.first
+
+        # Check if the argument is a constant
+        unless module_name = constant_as_type_name(first_arg)
+          diagnostics << Diagnostic::MixinNonConstantModule.new(
+            rbs_location(first_arg.location),
+            "Module name must be a constant"
+          )
+          return
+        end
+
+        # Look for type application annotation in trailing comments
+        # For single-line calls like "include Bar #[String]", the annotation is trailing
+        trailing_block = comments.trailing_block!(node.location)
+        annotation = nil
+
+        if trailing_block
+          case trailing_annotation = trailing_block.trailing_annotation([])
+          when AST::Ruby::Annotations::TypeApplicationAnnotation
+            annotation = trailing_annotation
+          else
+            report_unused_annotation(trailing_annotation)
+          end
+        end
+
+        # Create the appropriate member based on the method name
+        member = case node.name
+        when :include
+          AST::Ruby::Members::IncludeMember.new(buffer, node, module_name, annotation)
+        when :extend
+          AST::Ruby::Members::ExtendMember.new(buffer, node, module_name, annotation)
+        when :prepend
+          AST::Ruby::Members::PrependMember.new(buffer, node, module_name, annotation)
+        else
+          raise "Unexpected mixin method: #{node.name}"
+        end
+
+        current_module!.members << member
+      end
+
       def insert_declaration(decl)
         if current_module
           current_module.members << decl

sig/inline_parser.rbs

@@ -38,10 +38,17 @@ module RBS
       class AnnotationSyntaxError < Base
       end
 
+      class MixinMultipleArguments < Base
+      end
+
+      class MixinNonConstantModule < Base
+      end
+
       type t = NotImplementedYet
              | NonConstantClassName | NonConstantModuleName
              | TopLevelMethodDefinition
              | UnusedInlineAnnotation | AnnotationSyntaxError
+             | MixinMultipleArguments | MixinNonConstantModule
     end
 
     def self.parse: (Buffer, Prism::ParseResult) -> Result
@@ -82,6 +89,10 @@ module RBS
       def report_unused_annotation: (*AST::Ruby::Annotations::t | nil | AST::Ruby::CommentBlock::AnnotationSyntaxError) -> void
 
       def report_unused_block: (AST::Ruby::CommentBlock) -> void
+
+      private
+
+      def parse_mixin_call: (Prism::CallNode) -> void
     end
   end
 end

test/rbs/ast/ruby/comment_block_test.rb

@@ -216,4 +216,52 @@ def test_trailing_annotation
       assert_nil annotation
     end
   end
+
+  def test_trailing_annotation_type_application
+    buffer, comments = parse_comments(<<~RUBY)
+      foo #[String]
+
+      foo #[String, Integer]
+
+      foo #[String, Integer, void]
+
+      foo #[String[
+
+      foo #[String, Integer] # Extra comment
+    RUBY
+
+    blocks = CommentBlock.build(buffer, comments)
+
+    blocks[0].trailing_annotation([]).tap do |annotation|
+      assert_instance_of RBS::AST::Ruby::Annotations::TypeApplicationAnnotation, annotation
+      assert_equal 1, annotation.type_args.size
+      assert_equal "String", annotation.type_args[0].to_s
+    end
+
+    blocks[1].trailing_annotation([]).tap do |annotation|
+      assert_instance_of RBS::AST::Ruby::Annotations::TypeApplicationAnnotation, annotation
+      assert_equal 2, annotation.type_args.size
+      assert_equal "String", annotation.type_args[0].to_s
+      assert_equal "Integer", annotation.type_args[1].to_s
+    end
+
+    blocks[2].trailing_annotation([]).tap do |annotation|
+      assert_instance_of RBS::AST::Ruby::Annotations::TypeApplicationAnnotation, annotation
+      assert_equal 3, annotation.type_args.size
+      assert_equal "String", annotation.type_args[0].to_s
+      assert_equal "Integer", annotation.type_args[1].to_s
+      assert_equal "void", annotation.type_args[2].to_s
+    end
+
+    blocks[3].trailing_annotation([]).tap do |annotation|
+      assert_instance_of CommentBlock::AnnotationSyntaxError, annotation
+    end
+
+    blocks[4].trailing_annotation([]).tap do |annotation|
+      assert_instance_of RBS::AST::Ruby::Annotations::TypeApplicationAnnotation, annotation
+      assert_equal 2, annotation.type_args.size
+      assert_equal "String", annotation.type_args[0].to_s
+      assert_equal "Integer", annotation.type_args[1].to_s
+    end
+  end
 end