rbs-inline 0.3.0 → 0.5.0

data/lib/rbs/inline/ast/members.rb

@@ -4,15 +4,22 @@ module RBS
   module Inline
     module AST
       module Members
+        # @rbs!
+        #   type ruby = RubyDef | RubyAlias | RubyMixin | RubyAttr | RubyPublic | RubyPrivate
+        #
+        #   type rbs = RBSIvar | RBSEmbedded
+        #
+        #   type t = ruby | rbs
+
         class Base
-          attr_reader :location #:: Prism::Location
+          attr_reader :location #: Prism::Location
 
           # @rbs location: Prism::Location
-          def initialize(location) #:: void
+          def initialize(location) #: void
             @location = location
           end
 
-          def start_line #:: Integer
+          def start_line #: Integer
             location.start_line
           end
         end
@@ -21,8 +28,8 @@ module RBS
         end
 
         class RubyDef < RubyBase
-          attr_reader :node #:: Prism::DefNode
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
+          attr_reader :node #: Prism::DefNode
+          attr_reader :comments #: AnnotationParser::ParsingResult?
 
           # The visibility directly attached to the `def` node
           #
@@ -32,15 +39,17 @@ module RBS
           # def foo() end            # <= nil
           # private def foo() end    # <= :private
           # ```
-          attr_reader :visibility #:: RBS::AST::Members::visibility?
+          attr_reader :visibility #: RBS::AST::Members::visibility?
 
-          attr_reader :assertion #:: Annotations::Assertion?
+          # Assertion given at the end of the method name
+          #
+          attr_reader :assertion #: Annotations::TypeAssertion?
 
           # @rbs node: Prism::DefNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs visibility: RBS::AST::Members::visibility?
-          # @rbs assertion: Annotations::Assertion?
-          def initialize(node, comments, visibility, assertion) #:: void
+          # @rbs assertion: Annotations::TypeAssertion?
+          def initialize(node, comments, visibility, assertion) #: void
             @node = node
             @comments = comments
             @visibility = visibility
@@ -50,60 +59,53 @@ module RBS
           end
 
           # Returns the name of the method
-          def method_name #:: Symbol
+          def method_name #: Symbol
             node.name
           end
 
-          def method_type_annotations #:: Array[Annotations::Assertion]
-            if comments
-              comments.annotations.select do |annotation|
-                annotation.is_a?(Annotations::Assertion) && annotation.type.is_a?(MethodType)
-              end #: Array[Annotations::Assertion]
-            else
-              []
-            end
-          end
-
-          # Returns the `kind` of the method definition
+          # Returns `nil` if no `@rbs METHOD-TYPE` or `#:` annotation is given
           #
-          # [FIXME] It only supports `self` receiver.
-          #
-          # ```rb
-          # def self.foo = ()    # :singleton
-          # def object.foo = ()  # Not supported (returns :instance)
-          # ```
+          # Returns an empty array if only `...` method type is given.
           #
-          def method_kind #:: RBS::AST::Members::MethodDefinition::kind
-            # FIXME: really hacky implementation
-            case node.receiver
-            when Prism::SelfNode
-              :singleton
-            when nil
-              :instance
-            else
-              :instance
+          def annotated_method_types #: Array[MethodType]?
+            if comments
+              method_type_annotations = comments.each_annotation.select do |annotation|
+                annotation.is_a?(Annotations::MethodTypeAssertion) || annotation.is_a?(Annotations::Method) || annotation.is_a?(Annotations::Dot3Assertion)
+              end
+
+              return nil if method_type_annotations.empty?
+
+              method_type_annotations.each_with_object([]) do |annotation, method_types| #$ Array[MethodType]
+                case annotation
+                when Annotations::MethodTypeAssertion
+                  method_types << annotation.method_type
+                when Annotations::Method
+                  annotation.each_method_type do
+                    method_types << _1
+                  end
+                end
+              end
             end
           end
 
-          def return_type #:: Types::t?
+          def return_type #: Types::t?
             if assertion
-              if assertion.type?
-                return assertion.type?
-              end
+              return assertion.type
             end
+
             if comments
-              annot = comments.annotations.find {|annot| annot.is_a?(Annotations::ReturnType ) } #: Annotations::ReturnType?
+              annot = comments.each_annotation.find {|annot| annot.is_a?(Annotations::ReturnType ) } #: Annotations::ReturnType?
               if annot
                 annot.type
               end
             end
           end
 
-          def var_type_hash #:: Hash[Symbol, Types::t?]
+          def var_type_hash #: Hash[Symbol, Types::t?]
             types = {} #: Hash[Symbol, Types::t?]
 
             if comments
-              comments.annotations.each do |annotation|
+              comments.each_annotation.each do |annotation|
                 if annotation.is_a?(Annotations::VarType)
                   name = annotation.name
                   type = annotation.type
@@ -118,11 +120,42 @@ module RBS
             types
           end
 
-          def method_overloads #:: Array[RBS::AST::Members::MethodDefinition::Overload]
-            if !(annots = method_type_annotations).empty?
-              annots.map do
-                method_type = _1.type #: MethodType
+          def splat_param_type_annotation #: Annotations::SplatParamType?
+            if comments
+              comments.each_annotation.find do |annotation|
+                annotation.is_a?(Annotations::SplatParamType)
+              end #: Annotations::SplatParamType?
+            end
+          end
 
+          def double_splat_param_type_annotation #: Annotations::DoubleSplatParamType?
+            if comments
+              comments.each_annotation.find do |annotation|
+                annotation.is_a?(Annotations::DoubleSplatParamType)
+              end #: Annotations::DoubleSplatParamType?
+            end
+          end
+
+          def overloading? #: bool
+            if comments
+              comments.each_annotation do |annotation|
+                if annotation.is_a?(Annotations::Method)
+                  return true if annotation.overloading
+                end
+                if annotation.is_a?(Annotations::Dot3Assertion)
+                  return true
+                end
+              end
+              false
+            else
+              false
+            end
+          end
+
+          def method_overloads #: Array[RBS::AST::Members::MethodDefinition::Overload]
+            case
+            when method_types = annotated_method_types
+              method_types.map do |method_type|
                 RBS::AST::Members::MethodDefinition::Overload.new(
                   method_type: method_type,
                   annotations: []
@@ -160,22 +193,15 @@ module RBS
                 end
 
                 if (rest = node.parameters.rest).is_a?(Prism::RestParameterNode)
-                  rest_type =
-                    if rest.name
-                      var_type_hash[rest.name]
-                    end
-
-                  if rest_type
-                    if rest_type.is_a?(Types::ClassInstance)
-                      if rest_type.name.name == :Array && rest_type.name.namespace.empty?
-                        rest_type = rest_type.args[0]
-                      end
-                    end
+                  splat_param_type = splat_param_type_annotation
+
+                  if splat_param_type && splat_param_type.type
+                    splat_type = splat_param_type.type
                   end
 
                   rest_positionals = Types::Function::Param.new(
                     name: rest.name,
-                    type: rest_type || Types::Bases::Any.new(location: nil),
+                    type: splat_type || Types::Bases::Any.new(location: nil),
                     location: nil
                   )
                 end
@@ -199,60 +225,31 @@ module RBS
                 end
 
                 if (kw_rest = node.parameters.keyword_rest).is_a?(Prism::KeywordRestParameterNode)
-                  rest_type =
-                    if kw_rest.name
-                      var_type_hash[kw_rest.name]
-                    end
-
-                  if rest_type
-                    if rest_type.is_a?(Types::ClassInstance)
-                      if rest_type.name.name == :Hash && rest_type.name.namespace.empty?
-                        rest_type = rest_type.args[1]
-                      end
-                    end
+                  double_splat_param_type = double_splat_param_type_annotation
+
+                  if double_splat_param_type && double_splat_param_type.type
+                    double_splat_type = double_splat_param_type.type
                   end
 
                   rest_keywords = Types::Function::Param.new(
                     name: kw_rest.name,
-                    type: rest_type || Types::Bases::Any.new(location: nil),
+                    type: double_splat_type || Types::Bases::Any.new(location: nil),
                     location: nil)
                 end
 
                 if node.parameters.block
-                  if (block_name = node.parameters.block.name) && (var_type = var_type_hash[block_name])
-                    if var_type.is_a?(Types::Optional)
-                      optional = true
-                      var_type = var_type.type
-                    else
-                      optional = false
-                    end
-
-                    if var_type.is_a?(Types::Proc)
-                      block = Types::Block.new(type: var_type.type, self_type: var_type.self_type, required: !optional)
-                    end
-                  else
-                    block = Types::Block.new(
-                      type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
-                      required: false,
-                      self_type: nil
-                    )
-                  end
-                end
-              end
-
-              if annotation = yields_annotation
-                case annotation.block_type
-                when Types::Block
-                  block = annotation.block_type
-                else
                   block = Types::Block.new(
                     type: Types::UntypedFunction.new(return_type: Types::Bases::Any.new(location: nil)),
-                    required: !annotation.optional,
+                    required: false,
                     self_type: nil
                   )
                 end
               end
 
+              if type = block_type_annotation&.type
+                block = type
+              end
+
               [
                 RBS::AST::Members::MethodDefinition::Overload.new(
                   method_type: RBS::MethodType.new(
@@ -276,9 +273,9 @@ module RBS
             end
           end
 
-          def method_annotations #:: Array[RBS::AST::Annotation]
+          def method_annotations #: Array[RBS::AST::Annotation]
             if comments
-              comments.annotations.flat_map do |annotation|
+              comments.each_annotation.flat_map do |annotation|
                 if annotation.is_a?(AST::Annotations::RBSAnnotation)
                   annotation.contents.map do |string|
                     RBS::AST::Annotation.new(
@@ -295,44 +292,45 @@ module RBS
             end
           end
 
-          def override_annotation #:: AST::Annotations::Override?
+          # Returns the `@rbs override` annotation
+          def override_annotation #: AST::Annotations::Override?
             if comments
-              comments.annotations.find do |annotation|
+              comments.each_annotation.find do |annotation|
                 annotation.is_a?(AST::Annotations::Override)
               end #: AST::Annotations::Override?
             end
           end
 
-          def yields_annotation #:: AST::Annotations::Yields?
+          def block_type_annotation #: AST::Annotations::BlockType?
             if comments
-              comments.annotations.find do |annotation|
-                annotation.is_a?(AST::Annotations::Yields)
-              end #: AST::Annotations::Yields?
+              comments.each_annotation.find do |annotation|
+                annotation.is_a?(AST::Annotations::BlockType)
+              end #: AST::Annotations::BlockType?
             end
           end
         end
 
         class RubyAlias < RubyBase
-          attr_reader :node #:: Prism::AliasMethodNode
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
+          attr_reader :node #: Prism::AliasMethodNode
+          attr_reader :comments #: AnnotationParser::ParsingResult?
 
           # @rbs node: Prism::AliasMethodNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          def initialize(node, comments)
+          def initialize(node, comments) #: void
             @node = node
             @comments = comments
 
             super(node.location)
           end
 
-          # @rbs returns Symbol -- the name of *old* method
+          # @rbs return: Symbol -- the name of *old* method
           def old_name
             raise unless node.old_name.is_a?(Prism::SymbolNode)
             value = node.old_name.value or raise
             value.to_sym
           end
 
-          # @rbs returns Symbol -- the name of *new* method
+          # @rbs return: Symbol -- the name of *new* method
           def new_name
             raise unless node.new_name.is_a?(Prism::SymbolNode)
             value = node.new_name.value or raise
@@ -341,19 +339,21 @@ module RBS
         end
 
         class RubyMixin < RubyBase
+          include Declarations::ConstantUtil
+
           # CallNode that calls `include`, `prepend`, and `extend` method
-          attr_reader :node #:: Prism::CallNode
+          attr_reader :node #: Prism::CallNode
 
           # Comments attached to the call node
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
+          attr_reader :comments #: AnnotationParser::ParsingResult?
 
           # Possible following type application annotation
-          attr_reader :application #:: Annotations::Application?
+          attr_reader :application #: Annotations::Application?
 
           # @rbs node: Prism::CallNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs application: Annotations::Application?
-          # @rbs returns void
+          # @rbs return: void
           def initialize(node, comments, application)
             super(node.location)
 
@@ -362,7 +362,7 @@ module RBS
             @application = application
           end
 
-          # @rbs returns ::RBS::AST::Members::Include
+          # @rbs return: ::RBS::AST::Members::Include
           #            | ::RBS::AST::Members::Extend
           #            | ::RBS::AST::Members::Prepend
           #            | nil
@@ -371,11 +371,8 @@ module RBS
             return unless node.arguments.arguments.size == 1
 
             arg = node.arguments.arguments[0] || raise
-            if arg.is_a?(Prism::ConstantReadNode)
-              type_name = RBS::TypeName.new(name: arg.name, namespace: RBS::Namespace.empty)
-            else
-              raise
-            end
+            type_name = type_name(arg)
+            return unless type_name
 
             args = [] #: Array[Types::t]
             if application
@@ -414,14 +411,14 @@ module RBS
         end
 
         class RubyAttr < RubyBase
-          attr_reader :node #:: Prism::CallNode
-          attr_reader :comments #:: AnnotationParser::ParsingResult?
-          attr_reader :assertion #:: Annotations::Assertion?
+          attr_reader :node #: Prism::CallNode
+          attr_reader :comments #: AnnotationParser::ParsingResult?
+          attr_reader :assertion #: Annotations::TypeAssertion?
 
           # @rbs node: Prism::CallNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          # @rbs assertion: Annotations::Assertion?
-          # @rbs returns void
+          # @rbs assertion: Annotations::TypeAssertion?
+          # @rbs return: void
           def initialize(node, comments, assertion)
             super(node.location)
 
@@ -433,7 +430,7 @@ module RBS
           # @rbs return Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
           def rbs
             if comments
-              comment = RBS::AST::Comment.new(string: comments.content, location: nil)
+              comment = RBS::AST::Comment.new(string: comments.content(trim: true), location: nil)
             end
 
             klass =
@@ -478,7 +475,7 @@ module RBS
           #
           # Returns `untyped` when not annotated.
           #
-          def attribute_type #:: Types::t
+          def attribute_type #: Types::t
             type = assertion&.type
             raise if type.is_a?(MethodType)
 
@@ -489,10 +486,10 @@ module RBS
         # `private` call without arguments
         #
         class RubyPrivate < RubyBase
-          attr_reader :node #:: Prism::CallNode
+          attr_reader :node #: Prism::CallNode
 
           # @rbs node: Prism::CallNode
-          def initialize(node) #:: void
+          def initialize(node) #: void
             super(node.location)
             @node = node
           end
@@ -501,10 +498,10 @@ module RBS
         # `public` call without arguments
         #
         class RubyPublic < RubyBase
-          attr_reader :node #:: Prism::CallNode
+          attr_reader :node #: Prism::CallNode
 
           # @rbs node: Prism::CallNode
-          def initialize(node) #:: void
+          def initialize(node) #: void
             super(node.location)
             @node = node
           end
@@ -514,20 +511,20 @@ module RBS
         end
 
         class RBSIvar < RBSBase
-          attr_reader :annotation #:: Annotations::IvarType
+          attr_reader :annotation #: Annotations::IvarType
 
-          attr_reader :comment #:: AnnotationParser::ParsingResult
+          attr_reader :comment #: AnnotationParser::ParsingResult
 
           # @rbs comment: AnnotationParser::ParsingResult
           # @rbs annotation: Annotations::IvarType
-          def initialize(comment, annotation) #:: void
+          def initialize(comment, annotation) #: void
             @comment = comment
             @annotation = annotation
 
             super(comment.comments[0].location)
           end
 
-          def rbs #:: RBS::AST::Members::InstanceVariable | RBS::AST::Members::ClassInstanceVariable | nil
+          def rbs #: RBS::AST::Members::InstanceVariable | RBS::AST::Members::ClassInstanceVariable | nil
             if annotation.type
               if annotation.comment
                 string = annotation.comment.delete_prefix("--").lstrip
@@ -554,13 +551,13 @@ module RBS
         end
 
         class RBSEmbedded < RBSBase
-          attr_reader :annotation #:: Annotations::Embedded
+          attr_reader :annotation #: Annotations::Embedded
 
-          attr_reader :comment #:: AnnotationParser::ParsingResult
+          attr_reader :comment #: AnnotationParser::ParsingResult
 
           # @rbs comment: AnnotationParser::ParsingResult
           # @rbs annotation: Annotations::Embedded
-          def initialize(comment, annotation) #:: void
+          def initialize(comment, annotation) #: void
             @comment = comment
             @annotation = annotation
 
@@ -571,7 +568,7 @@ module RBS
           #
           # Returns `RBS::ParsingError` when the `content` has syntax error.
           #
-          def members #:: Array[RBS::AST::Members::t | RBS::AST::Declarations::t] | RBS::ParsingError
+          def members #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t] | RBS::ParsingError
             source = <<~RBS
               module EmbeddedModuleTest
                 #{annotation.content}