Implement DefinitionBuilder

Author: soutaro

lib/rbs/ast/ruby/members.rb

@@ -37,11 +37,19 @@ def overloads
               block: nil,
               location: nil
             )
-            
+
             [
               Overload.new(method_type: method_type, annotations: [])
             ]
           end
+
+          def overloading?
+            false
+          end
+
+          def annotations
+            []
+          end
         end
       end
     end

lib/rbs/definition.rb

@@ -62,7 +62,12 @@ def hash
         end
 
         def comment
-          member.comment
+          case member
+          when AST::Members::Base
+            member.comment
+          when AST::Ruby::Members::Base
+            nil
+          end
         end
 
         def update(type: self.type, member: self.member, defined_in: self.defined_in, implemented_in: self.implemented_in)

lib/rbs/definition_builder.rb

@@ -766,6 +766,37 @@ def define_method(methods, definition, method, subst, self_type_methods, defined
         )
 
         method_definition.annotations.replace(original.annotations)
+      when AST::Ruby::Members::DefMember
+        if duplicated_method = methods[method.name]
+          raise DuplicatedMethodDefinitionError.new(
+            type: definition.self_type,
+            method_name: method.name,
+            members: [original, *duplicated_method.members]
+          )
+        end
+
+        defs = original.overloads.map do |overload|
+          Definition::Method::TypeDef.new(
+            type: subst.empty? ? overload.method_type : overload.method_type.sub(subst),
+            member: original,
+            defined_in: defined_in,
+            implemented_in: implemented_in
+          ).tap do |type_def|
+            # Keep the original annotations given to overloads.
+            type_def.overload_annotations.replace(overload.annotations)
+          end
+        end
+
+        method_definition = Definition::Method.new(
+          super_method: existing_method,
+          defs: defs,
+          accessibility: :public,
+          alias_of: nil,
+          alias_member: nil
+        )
+
+        method_definition.annotations.replace([])
+
       when nil
         # Overloading method definition only
 

lib/rbs/definition_builder/method_builder.rb

@@ -105,7 +105,8 @@ def build_instance(type_name)
             Methods.new(type: type).tap do |methods|
               entry.each_decl do |decl|
                 subst = Substitution.build(decl.type_params.each.map(&:name), args)
-                if decl.is_a?(AST::Declarations::Base)
+                case decl
+                when AST::Declarations::Base
                   each_rbs_member_with_accessibility(decl.members) do |member, accessibility|
                     case member
                     when AST::Members::MethodDefinition
@@ -138,6 +139,18 @@ def build_instance(type_name)
                       end
                     end
                   end
+                when AST::Ruby::Declarations::Base
+                  decl.members.each do |member|
+                    case member
+                    when AST::Ruby::Members::DefMember
+                      build_method(
+                        methods,
+                        type,
+                        member: member,
+                        accessibility: :public
+                      )
+                    end
+                  end
                 end
               end
             end.validate!

sig/ast/ruby/members.rbs

@@ -23,6 +23,10 @@ module RBS
           def location: () -> Location
 
           def overloads: () -> Array[Overload]
+
+          def overloading?: () -> bool
+
+          def annotations: () -> Array[AST::Annotation]
         end
       end
     end

sig/definition.rbs

@@ -21,6 +21,7 @@ module RBS
 
     class Method
       type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
+                         | AST::Ruby::Members::DefMember
 
       class TypeDef
         attr_reader type: MethodType

sig/errors.rbs

@@ -226,12 +226,14 @@ module RBS
   class InvalidOverloadMethodError < DefinitionError
     include DetailedMessageable
 
+    type member = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
+
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
     attr_reader kind: :instance | :singleton
-    attr_reader members: Array[AST::Members::MethodDefinition]
+    attr_reader members: Array[member]
 
-    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
+    def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[member]) -> void
 
     def location: () -> AST::Members::MethodDefinition::loc?
   end

sig/method_builder.rbs

@@ -16,16 +16,19 @@ module RBS
         #
         class Definition
           type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
+                        | AST::Ruby::Members::DefMember
+
+          type overloading_definition = AST::Members::MethodDefinition | AST::Ruby::Members::DefMember
 
           type accessibility = RBS::Definition::accessibility
 
           attr_reader name: Symbol
           attr_reader type: instance_type
           attr_reader originals: Array[original]
-          attr_reader overloads: Array[AST::Members::MethodDefinition]
+          attr_reader overloads: Array[overloading_definition]
           attr_reader accessibilities: Array[accessibility]
 
-          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], accessibilities: Array[accessibility]) -> void
+          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[overloading_definition], accessibilities: Array[accessibility]) -> void
 
           def original: () -> original?
 
@@ -74,7 +77,7 @@ module RBS
 
       def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
 
-      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Definition::accessibility) -> void
+      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition | AST::Ruby::Members::DefMember, accessibility: Definition::accessibility) -> void
 
       def each_rbs_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
 

test/rbs/definition_builder_test.rb

@@ -3200,4 +3200,30 @@ module A
       end
     end
   end
+
+  def test_inline_decl__class_def
+    SignatureManager.new do |manager|
+      manager.add_ruby_file("inherited.rbs", <<~RUBY)
+        class A
+          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("(?) -> untyped")], method.method_types
+            assert_equal [parse_method_type("(?) -> untyped")], method.defs.map(&:type)
+
+            assert_equal [], method.annotations
+          end
+        end
+      end
+    end
+  end
 end

test/rbs/method_builder_test.rb

@@ -380,4 +380,32 @@ class Foo[A, B]
       end
     end
   end
+
+  def test_methods__inline
+    SignatureManager.new(system_builtin: true) do |manager|
+      manager.ruby_files[Pathname("foo.rb")] = <<EOF
+class Foo
+  def foo(x, y)
+    return x + y
+  end
+end
+EOF
+      manager.build do |env|
+        builder = MethodBuilder.new(env: env)
+
+        builder.build_instance(type_name("::Foo")).tap do |methods|
+          assert_equal parse_type("::Foo"), methods.type
+
+          methods.methods[:foo].tap do |foo|
+            assert_instance_of MethodBuilder::Methods::Definition, foo
+
+            assert_instance_of AST::Ruby::Members::DefMember, foo.original
+            assert_equal [parse_method_type("(?) -> untyped")], foo.original.overloads.map(&:method_type)
+
+            assert_equal :public, foo.accessibility
+          end
+        end
+      end
+    end
+  end
 end