Implement parsing

Author: soutaro

lib/rbs/ast/ruby/members.rb

@@ -294,6 +294,27 @@ class AttrWriterMember < AttributeMember
 
         class AttrAccessorMember < AttributeMember
         end
+
+        class InstanceVariableMember < Base
+          attr_reader :annotation
+
+          def initialize(buffer, annotation)
+            super(buffer)
+            @annotation = annotation
+          end
+
+          def name
+            annotation.ivar_name
+          end
+
+          def type
+            annotation.type
+          end
+
+          def location
+            annotation.location
+          end
+        end
       end
     end
   end

lib/rbs/inline_parser.rb

@@ -39,7 +39,11 @@ def initialize(location, message)
     def self.parse(buffer, prism)
       result = Result.new(buffer, prism)
 
-      Parser.new(result).visit(prism.value)
+      parser = Parser.new(result)
+      parser.visit(prism.value)
+      parser.comments.each_unassociated_block do |block|
+        parser.report_unused_block(block)
+      end
 
       result
     end
@@ -111,11 +115,36 @@ def visit_class_node(node)
         insert_declaration(class_decl)
         push_module_nesting(class_decl) do
           visit_child_nodes(node)
+
+          node.child_nodes.each do |child_node|
+            if child_node
+              comments.each_enclosed_block(child_node) do |block|
+                report_unused_block(block)
+              end
+            end
+          end
         end
 
         comments.each_enclosed_block(node) do |block|
-          report_unused_block(block)
+          unused_annotations = [] #: Array[AST::Ruby::CommentBlock::AnnotationSyntaxError | AST::Ruby::Annotations::leading_annotation]
+
+          block.each_paragraph([]) do |paragraph|
+            case paragraph
+            when AST::Ruby::Annotations::InstanceVariableAnnotation
+              class_decl.members << AST::Ruby::Members::InstanceVariableMember.new(buffer, paragraph)
+            when Location
+              # Skip
+            when AST::Ruby::CommentBlock::AnnotationSyntaxError
+              unused_annotations << paragraph
+            else
+              unused_annotations << paragraph
+            end
+          end
+
+          report_unused_annotation(*unused_annotations)
         end
+
+        class_decl.members.sort_by! { _1.location.start_line }
       end
 
       def visit_module_node(node)
@@ -169,7 +198,7 @@ def visit_def_node(node)
 
           # Skip other comments in `def` node
           comments.each_enclosed_block(node) do |block|
-            comments.associated_blocks << block
+            report_unused_block(block)
           end
         else
           diagnostics << Diagnostic::TopLevelMethodDefinition.new(
@@ -208,8 +237,6 @@ def visit_call_node(node)
         end
       end
 
-      private
-
       def parse_mixin_call(node)
         # Check for multiple arguments
         if node.arguments && node.arguments.arguments.length > 1
@@ -350,6 +377,8 @@ def report_unused_annotation(*annotations)
       end
 
       def report_unused_block(block)
+        return unless block.leading?
+
         block.each_paragraph([]) do |paragraph|
           case paragraph
           when Location

sig/ast/ruby/members.rbs

@@ -13,6 +13,7 @@ module RBS
         type t = DefMember
                | IncludeMember | ExtendMember | PrependMember
                | AttrReaderMember | AttrWriterMember | AttrAccessorMember
+               | InstanceVariableMember
 
         class MethodTypeAnnotation
           class DocStyle
@@ -125,6 +126,18 @@ module RBS
 
         class AttrAccessorMember < AttributeMember
         end
+
+        class InstanceVariableMember < Base
+          attr_reader annotation: Annotations::InstanceVariableAnnotation
+
+          def initialize: (Buffer, Annotations::InstanceVariableAnnotation) -> void
+
+          def name: () -> Symbol
+
+          def type: () -> Types::t
+
+          def location: () -> Location
+        end
       end
     end
   end

test/rbs/inline_parser_test.rb

@@ -1089,7 +1089,7 @@ def test_parse__class_with_super_class_and_members
     result = parse(<<~RUBY)
       class Person < ActiveRecord::Base #[Person]
         attr_reader :name #: String
-        
+
         def age
           25
         end
@@ -1107,7 +1107,7 @@ def age
       assert_equal "Person", decl.super_class.args[0].to_s
 
       assert_equal 2, decl.members.size
-      
+
       decl.members[0].tap do |member|
         assert_instance_of RBS::AST::Ruby::Members::AttrReaderMember, member
         assert_equal [:name], member.names
@@ -1120,4 +1120,87 @@ def age
       end
     end
   end
+
+  def test_parse__instance_variable
+    result = parse(<<~RUBY)
+      class Person
+        # @rbs @name: String
+        # @rbs @age: Integer?
+
+        def initialize(name, age)
+          @name = name
+          @age = age
+        end
+      end
+    RUBY
+
+    assert_empty result.diagnostics
+
+    result.declarations[0].tap do |decl|
+      assert_instance_of RBS::AST::Ruby::Declarations::ClassDecl, decl
+      assert_equal RBS::TypeName.parse("Person"), decl.class_name
+
+      # Should have 3 members: 2 instance variable members + 1 def member
+      assert_equal 3, decl.members.size
+
+      decl.members[0].tap do |member|
+        assert_instance_of RBS::AST::Ruby::Members::InstanceVariableMember, member
+        assert_equal :@name, member.name
+        assert_equal "String", member.type.to_s
+        assert_instance_of RBS::AST::Ruby::Annotations::InstanceVariableAnnotation, member.annotation
+      end
+
+      decl.members[1].tap do |member|
+        assert_instance_of RBS::AST::Ruby::Members::InstanceVariableMember, member
+        assert_equal :@age, member.name
+        assert_equal "Integer?", member.type.to_s
+        assert_instance_of RBS::AST::Ruby::Annotations::InstanceVariableAnnotation, member.annotation
+      end
+
+      decl.members[2].tap do |member|
+        assert_instance_of RBS::AST::Ruby::Members::DefMember, member
+        assert_equal :initialize, member.name
+      end
+    end
+  end
+
+  def test_error__instance_variable_ignored
+    result = parse(<<~RUBY)
+      # @rbs @global_decl: String
+
+      class Foo
+        def initialize
+          # @rbs @method_decl: Integer
+        end
+
+        tap do
+          # @rbs @block_decl: String
+        end
+
+        # @rbs @method_decl2: untyped
+        def foo
+        end
+      end
+    RUBY
+
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::UnusedInlineAnnotation, diagnostic
+      assert_equal "@rbs @global_decl: String", diagnostic.location.source
+    end
+
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::UnusedInlineAnnotation, diagnostic
+      assert_equal "@rbs @method_decl: Integer", diagnostic.location.source
+    end
+
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::UnusedInlineAnnotation, diagnostic
+      assert_equal "@rbs @method_decl2: untyped", diagnostic.location.source
+    end
+
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::UnusedInlineAnnotation, diagnostic
+      assert_equal "@rbs @block_decl: String", diagnostic.location.source
+    end
+  end
 end