rbs-inline 0.4.0 → 0.5.0

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

@@ -6,18 +6,20 @@ module RBS
       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
@@ -26,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
           #
@@ -37,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
@@ -55,39 +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]
+          # Returns `nil` if no `@rbs METHOD-TYPE` or `#:` annotation is given
+          #
+          # Returns an empty array if only `...` method type is given.
+          #
+          def annotated_method_types #: Array[MethodType]?
             if comments
-              comments.annotations.select do |annotation|
-                annotation.is_a?(Annotations::Assertion) && annotation.type.is_a?(MethodType)
-              end #: Array[Annotations::Assertion]
-            else
-              []
+              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
@@ -102,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: []
@@ -144,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
@@ -183,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(
@@ -260,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(
@@ -279,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
@@ -328,18 +342,18 @@ module RBS
           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)
 
@@ -348,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
@@ -397,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)
 
@@ -416,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 =
@@ -461,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)
 
@@ -472,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
@@ -484,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
@@ -497,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
@@ -537,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
 
@@ -554,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}

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

@@ -3,26 +3,27 @@
 module RBS
   module Inline
     module AST
-      class Tree
-        # @rbs!
-        #   type token = [Symbol, String]
-        #   type tree = token | Tree | Types::t | MethodType | nil
+      # @rbs!
+      #   type token = [Symbol, String]
+      #
+      #   type tree = token | Tree | Types::t | MethodType | nil
 
-        attr_reader :trees #:: Array[tree]
-        attr_reader :type #:: Symbol
+      class Tree
+        attr_reader :trees #: Array[tree]
+        attr_reader :type #: Symbol
 
         # Children but without `tWHITESPACE` tokens
-        attr_reader :non_trivia_trees #:: Array[tree]
+        attr_reader :non_trivia_trees #: Array[tree]
 
         # @rbs type: Symbol
-        def initialize(type)
+        def initialize(type) #: void
           @type = type
           @trees = []
           @non_trivia_trees = []
         end
 
         # @rbs tok: tree
-        # @rbs returns self
+        # @rbs return: self
         def <<(tok)
           trees << tok
           unless tok.is_a?(Array) && tok[0] == :tWHITESPACE
@@ -32,7 +33,7 @@ module RBS
         end
 
         # Returns the source code associated to the tree
-        def to_s #:: String
+        def to_s #: String
           buf = +""
 
           trees.each do |tree|
@@ -51,12 +52,26 @@ module RBS
           buf
         end
 
+        # Returns `true` if token at the given index is of the given type
+        def token?(type, at:)
+          if tok = nth_token?(at)
+            tok[0] == type
+          end
+        end
+
+        # Returns `true` if tree at the given index is of the given type
+        def tree?(type, at:)
+          if tree = nth_tree?(at)
+            tree.type == type
+          end
+        end
+
         # Returns n-th token from the children
         #
         # Raises if the value is not a token or nil.
         #
         # @rbs index: Integer
-        # @rbs returns token?
+        # @rbs return: token?
         def nth_token(index)
           tok = non_trivia_trees[index]
           case tok
@@ -72,7 +87,7 @@ module RBS
         # Returns `nil` if the value is not a token.
         #
         # @rbs index: Integer
-        # @rbs returns token?
+        # @rbs return: token?
         def nth_token?(index)
           tok = non_trivia_trees[index]
           case tok
@@ -88,7 +103,7 @@ module RBS
         # Raises if the value is not token.
         #
         # @rbs index: Integer
-        # @rbs returns token
+        # @rbs return: token
         def nth_token!(index)
           nth_token(index) || raise
         end
@@ -98,7 +113,7 @@ module RBS
         # Raises if the value is not a tree or nil.
         #
         # @rbs index: Integer
-        # @rbs returns Tree?
+        # @rbs return: Tree?
         def nth_tree(index)
           tok = non_trivia_trees[index]
           case tok
@@ -114,7 +129,7 @@ module RBS
         # Returns `nil` if the value is not a tree or nil.
         #
         # @rbs index: Integer
-        # @rbs returns Tree?
+        # @rbs return: Tree?
         def nth_tree?(index)
           tok = non_trivia_trees[index]
           case tok
@@ -130,7 +145,7 @@ module RBS
         # Raises if the value is not a tree.
         #
         # @rbs index: Integer
-        # @rbs returns Tree
+        # @rbs return: Tree
         def nth_tree!(index)
           nth_tree(index) || raise
         end
@@ -141,7 +156,7 @@ module RBS
         # Raises if the value is not a type or nil.
         #
         # @rbs index: Integer
-        # @rbs returns Types::t?
+        # @rbs return: Types::t?
         def nth_type(index)
           tok = non_trivia_trees[index]
           case tok
@@ -157,7 +172,7 @@ module RBS
         # Returns `nil` if the value is not a type.
         #
         # @rbs index: Integer
-        # @rbs returns Types::t?
+        # @rbs return: Types::t?
         def nth_type?(index)
           tok = non_trivia_trees[index]
           case tok
@@ -173,7 +188,7 @@ module RBS
         # Raises if the value is not a type.
         #
         # @rbs index: Integer
-        # @rbs returns Types::t
+        # @rbs return: Types::t
         def nth_type!(index)
           nth_type(index) || raise
         end
@@ -183,7 +198,7 @@ module RBS
         # Raises if the value is not a method type or `nil`.
         #
         # @rbs index: Integer
-        # @rbs returns MethodType?
+        # @rbs return: MethodType?
         def nth_method_type(index)
           tok = non_trivia_trees[index]
           case tok
@@ -199,7 +214,7 @@ module RBS
         # Returns `nil` if the value is not a method type.
         #
         # @rbs index: Integer
-        # @rbs returns MethodType?
+        # @rbs return: MethodType?
         def nth_method_type?(index)
           tok = non_trivia_trees[index]
           case tok
@@ -215,7 +230,7 @@ module RBS
         # Raises if the value is not a method tree.
         #
         # @rbs index: Integer
-        # @rbs returns MethodType
+        # @rbs return: MethodType
         def nth_method_type!(index)
           nth_method_type(index) || raise
         end