Merge pull request #2392 from ruby/inline-def

Inline `def` support

Author: soutaro

lib/rbs.rb

@@ -28,6 +28,7 @@
 require "rbs/ast/ruby/helpers/constant_helper"
 require "rbs/ast/ruby/helpers/location_helper"
 require "rbs/ast/ruby/declarations"
+require "rbs/ast/ruby/members"
 require "rbs/source"
 require "rbs/inline_parser"
 require "rbs/environment"

lib/rbs/ast/ruby/members.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RBS
+  module AST
+    module Ruby
+      module Members
+        class Base
+          attr_reader :buffer
+
+          def initialize(buffer)
+            @buffer = buffer
+          end
+
+          include Helpers::LocationHelper
+        end
+
+        class DefMember < Base
+          Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader :name
+          attr_reader :node
+
+          def initialize(buffer, name, node)
+            super(buffer)
+            @name = name
+            @node = node
+          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: [])
+            ]
+          end
+
+          def overloading?
+            false
+          end
+
+          def annotations
+            []
+          end
+        end
+      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!

lib/rbs/environment.rb

@@ -672,6 +672,8 @@ def resolve_ruby_decl(resolver, decl, context:, prefix:)
             case member
             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
             else
               raise "Unknown member type: #{member.class}"
             end

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/ast/ruby/declarations.rbs

@@ -14,7 +14,7 @@ module RBS
         end
 
         class ClassDecl < Base
-          type member = t
+          type member = t | Members::t
 
           attr_reader class_name: TypeName
 
@@ -35,7 +35,7 @@ module RBS
         end
 
         class ModuleDecl < Base
-          type member = t
+          type member = t | Members::t
 
           attr_reader module_name: TypeName
 

sig/ast/ruby/members.rbs

@@ -0,0 +1,34 @@
+module RBS
+  module AST
+    module Ruby
+      module Members
+        class Base
+          attr_reader buffer: Buffer
+
+          def initialize: (Buffer) -> void
+
+          include Helpers::LocationHelper
+        end
+
+        type t = DefMember
+
+        class DefMember < Base
+          class Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader name: Symbol
+          attr_reader node: Prism::DefNode
+
+          def initialize: (Buffer, Symbol name, Prism::DefNode node) -> void
+
+          def location: () -> Location
+
+          def overloads: () -> Array[Overload]
+
+          def overloading?: () -> bool
+
+          def annotations: () -> Array[AST::Annotation]
+        end
+      end
+    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