Implement InlineParser

Author: soutaro

lib/rbs/inline_parser.rb

@@ -23,8 +23,10 @@ def initialize(location, message)
         end
       end
 
+      NotImplementedYet = _ = Class.new(Base)
       NonConstantClassName = _ = Class.new(Base)
       NonConstantModuleName = _ = Class.new(Base)
+      TopLevelMethodDefinition = _ = Class.new(Base)
     end
 
     def self.parse(buffer, prism)
@@ -101,6 +103,27 @@ def visit_module_node(node)
         end
       end
 
+      def visit_def_node(node)
+        if node.receiver
+          diagnostics << Diagnostic::NotImplementedYet.new(
+            rbs_location(node.receiver.location),
+            "Singleton method definition is not supported yet"
+          )
+          return
+        end
+
+        case current = current_module
+        when AST::Ruby::Declarations::ClassDecl, AST::Ruby::Declarations::ModuleDecl
+          defn = AST::Ruby::Members::DefMember.new(buffer, node.name, node)
+          current.members << defn
+        else
+          diagnostics << Diagnostic::TopLevelMethodDefinition.new(
+            rbs_location(node.name_loc),
+            "Top-level method definition is not supported"
+          )
+        end
+      end
+
       def insert_declaration(decl)
         if current_module
           current_module.members << decl

sig/inline_parser.rbs

@@ -20,13 +20,21 @@ module RBS
         def initialize: (Location, String) -> void
       end
 
+      class NotImplementedYet < Base
+      end
+
       class NonConstantClassName < Base
       end
 
       class NonConstantModuleName < Base
       end
 
-      type t = NonConstantClassName | NonConstantModuleName
+      class TopLevelMethodDefinition < Base
+      end
+
+      type t = NotImplementedYet
+             | NonConstantClassName | NonConstantModuleName
+             | TopLevelMethodDefinition
     end
 
     def self.parse: (Buffer, Prism::ParseResult) -> Result

test/rbs/inline_parser_test.rb

@@ -87,4 +87,56 @@ module World
 
     assert_empty result.declarations
   end
+
+  def test_parse__def
+    result = parse(<<~RUBY)
+      class Foo
+        def foo; end
+      end
+    RUBY
+
+    assert_empty result.diagnostics
+
+    assert_equal 1, result.declarations.size
+    result.declarations[0].tap do |decl|
+      assert_instance_of RBS::AST::Ruby::Declarations::ClassDecl, decl
+      assert_equal RBS::TypeName.parse("Foo"), decl.class_name
+
+      decl.members[0].tap do |member|
+        assert_instance_of RBS::AST::Ruby::Members::DefMember, member
+        assert_equal :foo, member.name
+        assert_equal "def foo; end", member.location.source
+      end
+    end
+  end
+
+  def test_error__def__toplevel
+    result = parse(<<~RUBY)
+      def foo; end
+    RUBY
+
+    assert_equal 1, result.diagnostics.size
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::TopLevelMethodDefinition, diagnostic
+      assert_equal "foo", diagnostic.location.source
+      assert_equal "Top-level method definition is not supported", diagnostic.message
+    end
+
+    assert_empty result.declarations
+  end
+
+  def test_error__def__singleton
+    result = parse(<<~RUBY)
+      module Foo
+        def self.foo; end
+      end
+    RUBY
+
+    assert_equal 1, result.diagnostics.size
+    assert_any!(result.diagnostics) do |diagnostic|
+      assert_instance_of RBS::InlineParser::Diagnostic::NotImplementedYet, diagnostic
+      assert_equal "self", diagnostic.location.source
+      assert_equal "Singleton method definition is not supported yet", diagnostic.message
+    end
+  end
 end