rbs-inline 0.4.0 → 0.5.0

data/sig/generated/rbs/inline/annotation_parser.rbs

@@ -3,127 +3,148 @@
 module RBS
   module Inline
     class AnnotationParser
+      # ParsingResut groups consecutive comments, which may contain several annotations
+      #
+      # *Consecutive comments* are comments are defined in below.
+      # They are basically comments that follows from the previous line, but there are some more requirements.
+      #
+      # ```ruby
+      # # Line 1
+      # # Line 2           #=> Line 1 and Line 2 are consecutive
+      #
+      #    # Line 3
+      #  # Line4           #=> Line 3 and Line 4 are not consecutive, because the starting column are different
+      #
+      #         # Line 5
+      # foo()   # Line 6   #=> Line 5 and Line 6 are not consecutive, because Line 6 has leading code
+      # ```
       class ParsingResult
         attr_reader comments: Array[Prism::Comment]
 
-        attr_reader annotations: Array[AST::Annotations::t]
+        attr_reader annotations: Array[AST::Annotations::t | AST::CommentLines]
 
         attr_reader first_comment_offset: Integer
 
+        # : () { (AST::Annotations::t) -> void } -> void
+        # : () -> Enumerator[AST::Annotations::t, void]
+        def each_annotation: () { (AST::Annotations::t) -> void } -> void
+                           | () -> Enumerator[AST::Annotations::t, void]
+
         # @rbs first_comment: Prism::Comment
-        def initialize: (Prism::Comment first_comment) -> untyped
+        def initialize: (Prism::Comment first_comment) -> void
 
-        # @rbs returns Range[Integer]
+        # @rbs return: Range[Integer]
         def line_range: () -> Range[Integer]
 
-        # @rbs returns Prism::Comment
+        # @rbs return: Prism::Comment
         def last_comment: () -> Prism::Comment
 
         # @rbs comment: Prism::Comment
-        # @rbs returns self?
+        # @rbs return: self?
         def add_comment: (Prism::Comment comment) -> self?
 
-        # @rbs returns Array[[String, Prism::Comment]]
-        def lines: () -> Array[[ String, Prism::Comment ]]
+        # @rbs trim: bool -- `true` to trim the leading whitespaces
+        def content: (?trim: bool) -> String
 
-        # @rbs returns String
-        def content: () -> String
+        def lines: () -> Array[String]
       end
 
+      include Tokens
+
       attr_reader input: Array[Prism::Comment]
 
       # @rbs input: Array[Prism::Comment]
-      def initialize: (Array[Prism::Comment] input) -> untyped
+      def initialize: (Array[Prism::Comment] input) -> void
 
       # @rbs input: Array[Prism::Comment]
-      # @rbs returns Array[ParsingResult]
+      # @rbs return: Array[ParsingResult]
       def self.parse: (Array[Prism::Comment] input) -> Array[ParsingResult]
 
-      # @rbs returns Array[ParsingResult]
+      # @rbs return: Array[ParsingResult]
       def parse: () -> Array[ParsingResult]
 
       private
 
-      # @rbs result: ParsingResult
-      # @rbs block: ^(Array[Prism::Comment]) -> void
-      # @rbs returns void
-      def each_annotation_paragraph: (ParsingResult result) { (Array[Prism::Comment]) -> void } -> void
-
-      class Tokenizer
-        attr_reader scanner: StringScanner
-
-        attr_reader current_token: token?
-
-        KEYWORDS: Hash[String, Symbol]
-
-        KW_RE: ::Regexp
-
-        PUNCTS: Hash[String, Symbol]
-
-        PUNCTS_RE: Regexp
-
-        # @rbs scanner: StringScanner
-        # @rbs returns void
-        def initialize: (StringScanner scanner) -> void
-
-        # @rbs tree: AST::Tree
-        # @rbs returns token?
-        def advance: (AST::Tree tree) -> token?
-
-        # Consume given token type and inserts the token to the tree or `nil`
-        #
-        # @rbs type: Array[Symbol]
-        # @rbs tree: AST::Tree
-        # @rbs returns void
-        def consume_token: (*untyped types, tree: AST::Tree) -> void
-
-        # Consume given token type and inserts the token to the tree or raise
-        #
-        # @rbs type: Array[Symbol]
-        # @rbs tree: AST::Tree
-        # @rbs returns void
-        def consume_token!: (*untyped types, tree: AST::Tree) -> void
+      # Test if the comment is an annotation comment
+      #
+      # - Returns `nil` if the comment is not an annotation.
+      # - Returns `true` if the comment is `#:` or `#[` annotation. (Offset is `1`)
+      # - Returns Integer if the comment is `#@rbs` annotation. (Offset is the number of leading spaces including `#`)
+      #
+      # : (Prism::Comment) -> (Integer | true | nil)
+      def annotation_comment?: (Prism::Comment) -> (Integer | true | nil)
 
-        # Test if current token has specified `type`
-        #
-        # @rbs type: Array[Symbol]
-        # @rbs returns bool
-        def type?: (*Symbol type) -> bool
+      # Split lines of comments in `result` into paragraphs
+      #
+      # A paragraph consists of:
+      #
+      # * An annotation syntax constructs -- starting with `@rbs` or `::`, or
+      # * A lines something else
+      #
+      # Yields an array of comments, and a boolean indicating if the comments may be an annotation.
+      #
+      # : (ParsingResult) { (Array[Prism::Comment], bool is_annotation) -> void } -> void
+      def each_annotation_paragraph: (ParsingResult) { (Array[Prism::Comment], bool is_annotation) -> void } -> void
 
-        # Ensure current token is one of the specified in types
-        #
-        # @rbs types: Array[Symbol]
-        # @rbs returns void
-        def type!: (*Symbol types) -> void
+      # The first annotation line is already detected and consumed.
+      # The annotation comment is already in `comments`.
+      #
+      # @rbs comments: Array[Prism::Comment] -- Annotation comments
+      # @rbs lines: Array[Prism::Comment] -- Lines to be consumed
+      # @rbs offset: Integer -- Offset of the first character of the first annotation comment from the `#` (>= 1)
+      # @rbs allow_empty_lines: bool -- `true` if empty line is allowed inside the annotation comments
+      # @rbs &block: (Array[Prism::Comment], bool is_annotation) -> void
+      # @rbs return: void
+      def yield_annotation: (Array[Prism::Comment] comments, Array[Prism::Comment] lines, Integer offset, allow_empty_lines: bool) { (Array[Prism::Comment], bool is_annotation) -> void } -> void
+
+      # The first line is NOT consumed.
+      #
+      # The `comments` may be empty.
+      #
+      # @rbs comments: Array[Prism::Comment] -- Leading comments
+      # @rbs lines: Array[Prism::Comment] -- Lines to be consumed
+      # @rbs &block: (Array[Prism::Comment], bool is_annotation) -> void
+      # @rbs return: void
+      def yield_paragraph: (Array[Prism::Comment] comments, Array[Prism::Comment] lines) { (Array[Prism::Comment], bool is_annotation) -> void } -> void
 
-        # Reset the current_token to incoming comment `--`
-        #
-        # Reset to the end of the input if `--` token cannot be found.
-        #
-        # @rbs returns String -- String that is skipped
-        def skip_to_comment: () -> String
-      end
+      # Consumes empty lines between annotation lines
+      #
+      # An empty line is already detected and consumed.
+      # The line is already removed from `lines` and put in `empty_comments`.
+      #
+      # Note that the arguments, `comments`, `empty_comments`, and `lines` are modified in place.
+      #
+      # @rbs comments: Array[Prism::Comment] -- Non empty annotation comments
+      # @rbs empty_comments: Array[Prism::Comment] -- Empty comments that may be part of the annotation
+      # @rbs lines: Array[Prism::Comment] -- Lines
+      # @rbs offset: Integer -- Offset of the first character of the annotation
+      # @rbs &block: (Array[Prism::Comment], bool is_annotation) -> void
+      # @rbs return: void
+      def yield_empty_annotation: (Array[Prism::Comment] comments, Array[Prism::Comment] empty_comments, Array[Prism::Comment] lines, Integer offset) { (Array[Prism::Comment], bool is_annotation) -> void } -> void
 
       # @rbs comments: AST::CommentLines
-      # @rbs returns AST::Annotations::t?
+      # @rbs return: AST::Annotations::t?
       def parse_annotation: (AST::CommentLines comments) -> AST::Annotations::t?
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_var_decl: (Tokenizer tokenizer) -> AST::Tree
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_return_type_decl: (Tokenizer tokenizer) -> AST::Tree
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_comment: (Tokenizer tokenizer) -> AST::Tree
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_type_app: (Tokenizer tokenizer) -> AST::Tree
 
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_method_type_annotation: (Tokenizer) -> AST::Tree
+
       # Parse a RBS method type or type and returns it
       #
       # It tries parsing a method type, and then parsing a type if failed.
@@ -134,9 +155,20 @@ module RBS
       #
       # @rbs tokenizer: Tokenizer
       # @rbs parent_tree: AST::Tree
-      # @rbs returns MethodType | AST::Tree | Types::t | nil
+      # @rbs return: MethodType | AST::Tree | Types::t | nil
       def parse_type_method_type: (Tokenizer tokenizer, AST::Tree parent_tree) -> (MethodType | AST::Tree | Types::t | nil)
 
+      # Parse a RBS method type
+      #
+      # If parsing failed, it returns a Tree(`:type_syntax_error), consuming all of the remaining input.
+      #
+      # Note that this doesn't recognize `--` comment unlike `parse_type`.
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs parent_tree: AST::Tree
+      # @rbs return: MethodType | AST::Tree
+      def parse_method_type: (Tokenizer tokenizer, AST::Tree parent_tree) -> (MethodType | AST::Tree)
+
       # Parse a RBS type and returns it
       #
       # If parsing failed, it returns a Tree(`:type_syntax_error), consuming
@@ -152,27 +184,27 @@ module RBS
       #
       # @rbs tokenizer: Tokenizer
       # @rbs parent_tree: AST::Tree
-      # @rbs returns Types::t | AST::Tree | nil
+      # @rbs return: Types::t | AST::Tree | nil
       def parse_type: (Tokenizer tokenizer, AST::Tree parent_tree) -> (Types::t | AST::Tree | nil)
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_rbs_annotation: (Tokenizer tokenizer) -> AST::Tree
 
-      # @rbs tokznier: Tokenizer
-      # @rbs returns AST::Tree
-      def parse_inherits: (untyped tokenizer) -> AST::Tree
+      # @rbs tokenizer: Tokenizer
+      # @rbs return: AST::Tree
+      def parse_inherits: (Tokenizer tokenizer) -> AST::Tree
 
       # Parse `@rbs override` annotation
       #
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_override: (Tokenizer tokenizer) -> AST::Tree
 
       # Parse `@rbs use [CLAUSES]` annotation
       #
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_use: (Tokenizer tokenizer) -> AST::Tree
 
       # Parses use clause
@@ -185,11 +217,11 @@ module RBS
       # * [`::`?, [UIDENT) `::`]*, `*`]
       #
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_use_clause: (Tokenizer tokenizer) -> AST::Tree
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_module_self: (Tokenizer tokenizer) -> AST::Tree
 
       # Yield the block and return the resulting tree if tokenizer has current token of `types`
@@ -197,26 +229,50 @@ module RBS
       # ```rb
       # # Test if tokenize has `--` token, then parse comment or insert `nil` to tree
       #
-      # tree << parse_optional(tokenizer, :kMINUS2) do
+      # tree << parse_optional(tokenizer, K_MINUS2) do
       #   parse_comment(tokenizer)
       # end
       # ```
       #
+      # If `tree:` is given, it consumes trivia tokens before yielding the block.
+      #
       # @rbs tokenizer: Tokenizer
-      # @rbs types: Array[Symbol]
-      # @rbs block: ^() -> AST::Tree
-      # @rbs returns AST::Tree?
-      def parse_optional: (Tokenizer tokenizer, *Symbol types) { () -> AST::Tree } -> AST::Tree?
+      # @rbs *types: Symbol
+      # @rbs tree: AST::Tree? -- the parent tree to consume leading trivia tokens
+      # @rbs &block: () -> AST::Tree
+      # @rbs return: AST::Tree?
+      def parse_optional: (Tokenizer tokenizer, *Symbol types, ?tree: AST::Tree?) { () -> AST::Tree } -> AST::Tree?
 
       # @rbs tokenizer: Tokenizer
-      # @rbs returns AST::Tree
+      # @rbs return: AST::Tree
       def parse_generic: (Tokenizer tokenizer) -> AST::Tree
 
-      # :: (Tokenizer) -> AST::Tree
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_type_param: (Tokenizer) -> AST::Tree
+
+      # : (Tokenizer) -> AST::Tree
       def parse_ivar_type: (Tokenizer) -> AST::Tree
 
-      # :: (Tokenizer) -> AST::Tree
-      def parse_yields: (Tokenizer) -> AST::Tree
+      # : (Tokenizer) -> AST::Tree
+      def parse_splat_param_type: (Tokenizer) -> AST::Tree
+
+      # : (Tokenizer) -> AST::Tree
+      def parse_block_type: (Tokenizer) -> AST::Tree
+
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_module_decl: (Tokenizer) -> AST::Tree
+
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_class_decl: (Tokenizer) -> AST::Tree
+
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_module_name: (Tokenizer) -> AST::Tree
+
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_type_params: (Tokenizer) -> AST::Tree
+
+      # @rbs (Tokenizer) -> AST::Tree
+      def parse_module_selfs: (Tokenizer) -> AST::Tree
     end
   end
 end

data/sig/generated/rbs/inline/ast/annotations.rbs

@@ -4,7 +4,24 @@ module RBS
   module Inline
     module AST
       module Annotations
-        type t = VarType | ReturnType | Use | Inherits | Generic | ModuleSelf | Skip | Assertion | Application | RBSAnnotation | Override | IvarType | Yields | Embedded
+        type t = VarType | ReturnType | Use | Inherits | Generic | ModuleSelf | Skip | MethodTypeAssertion | TypeAssertion | SyntaxErrorAssertion | Dot3Assertion | Application | RBSAnnotation | Override | IvarType | Embedded | Method | SplatParamType | DoubleSplatParamType | BlockType | ModuleDecl | ClassDecl
+
+        module Utils
+          # @rbs (Tree) -> RBS::AST::TypeParam?
+          def translate_type_param: (Tree) -> RBS::AST::TypeParam?
+
+          # @rbs (Types::t) -> RBS::AST::Declarations::Class::Super?
+          def translate_super_class: (Types::t) -> RBS::AST::Declarations::Class::Super?
+
+          # Assumes the tree is generated through `#parse_module_name`
+          #
+          # Returns a type name, or `nil` if the tree is something invalid.
+          #
+          # @param tree -- A tree object that is generated through `#parse_module_name`
+          #
+          # @rbs (AST::Tree) -> TypeName?
+          def translate_type_name: (AST::Tree) -> TypeName?
+        end
 
         class Base
           attr_reader source: CommentLines
@@ -13,7 +30,7 @@ module RBS
 
           # @rbs tree: Tree
           # @rbs source: CommentLines
-          # @rbs returns void
+          # @rbs return: void
           def initialize: (Tree tree, CommentLines source) -> void
         end
 
@@ -27,11 +44,46 @@ module RBS
           # @rbs override
           def initialize: ...
 
-          # :: () -> bool
+          # : () -> bool
           def complete?: () -> bool
         end
 
-        # `@rbs returns T`
+        class SpecialVarTypeAnnotation < Base
+          attr_reader name: Symbol?
+
+          attr_reader type: Types::t?
+
+          attr_reader comment: String?
+
+          attr_reader type_source: String
+
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `@rbs *x: T`
+        class SplatParamType < SpecialVarTypeAnnotation
+        end
+
+        # `@rbs` **x: T
+        class DoubleSplatParamType < SpecialVarTypeAnnotation
+        end
+
+        # `@rbs &block: METHOD-TYPE` or `@rbs &block: ? METHOD-TYPE`
+        class BlockType < Base
+          attr_reader name: Symbol?
+
+          attr_reader type: Types::Block?
+
+          attr_reader comment: String?
+
+          attr_reader type_source: String
+
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `@rbs return: T`
         class ReturnType < Base
           attr_reader type: Types::t?
 
@@ -40,7 +92,7 @@ module RBS
           # @rbs override
           def initialize: ...
 
-          # @rbs returns bool
+          # @rbs return: bool
           def complete?: () -> bool
         end
 
@@ -58,53 +110,45 @@ module RBS
           def initialize: ...
         end
 
-        # `#:: TYPE`
-        class Assertion < Base
-          attr_reader type: Types::t | MethodType | nil
+        class MethodTypeAssertion < Base
+          attr_reader method_type: MethodType
 
-          def initialize: (untyped tree, untyped source) -> untyped
-
-          # @rbs returns bool
-          def complete?: () -> bool
-
-          # Returns a type if it's type
-          def type?: () -> Types::t?
+          # @rbs override
+          def initialize: ...
 
-          # Returns a method type if it's a method type
-          def method_type?: () -> MethodType?
+          def type_source: () -> String
         end
 
-        # `#[TYPE, ..., TYPE]`
-        class Application < Base
-          attr_reader types: Array[Types::t]?
+        class TypeAssertion < Base
+          attr_reader type: Types::t
 
           # @rbs override
           def initialize: ...
 
-          # @rbs returns bool
-          def complete?: () -> bool
+          def type_source: () -> String
         end
 
-        # `# @rbs yields () -> void -- Comment`
-        class Yields < Base
-          # The type of block
-          #
-          # * Types::Block when syntactically correct input is given
-          # * String when syntax error is reported
-          # * `nil` when nothing is given
-          attr_reader block_type: Types::Block | String | nil
+        class SyntaxErrorAssertion < Base
+          attr_reader error_string: String
 
-          # The content of the comment or `nil`
-          attr_reader comment: String?
+          # @rbs override
+          def initialize: ...
+        end
 
-          # If `[optional]` token is inserted just after `yields` token
-          #
-          # The Types::Block instance has correct `required` attribute based on the `[optional]` token.
-          # This is for the other cases, syntax error or omitted.
-          attr_reader optional: bool
+        class Dot3Assertion < Base
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `#[TYPE, ..., TYPE]`
+        class Application < Base
+          attr_reader types: Array[Types::t]?
 
           # @rbs override
           def initialize: ...
+
+          # @rbs return: bool
+          def complete?: () -> bool
         end
 
         # `# @rbs %a{a} %a{a} ...`
@@ -170,6 +214,8 @@ module RBS
 
           attr_reader comment: String?
 
+          include Utils
+
           # @rbs override
           def initialize: ...
         end
@@ -181,6 +227,64 @@ module RBS
           # @rbs override
           def initialize: ...
         end
+
+        # `@rbs METHOD-TYPE``
+        class Method < Base
+          type method_type = [ MethodType, method_type? ] | String
+
+          attr_reader method_types: method_type?
+
+          # `true` if the method definition is overloading something
+          attr_reader overloading: bool
+
+          attr_reader type: MethodType?
+
+          attr_reader method_type_source: String
+
+          # @rbs override
+          def initialize: ...
+
+          # : (Array[tree]) -> method_type?
+          def construct_method_types: (Array[tree]) -> method_type?
+
+          # @rbs () { (MethodType) -> void } -> void
+          #    | () -> Enumerator[MethodType, void]
+          def each_method_type: () { (MethodType) -> void } -> void
+                              | () -> Enumerator[MethodType, void]
+
+          # Returns the parsing error overload string
+          #
+          # Returns `nil` if no parsing error found.
+          def error_source: () -> String?
+        end
+
+        # `@rbs module Foo`
+        class ModuleDecl < Base
+          attr_reader name: TypeName?
+
+          attr_reader type_params: Array[RBS::AST::TypeParam]
+
+          attr_reader self_types: Array[RBS::AST::Declarations::Module::Self]
+
+          include Utils
+
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `@rbs class Foo`
+        class ClassDecl < Base
+          attr_reader name: TypeName?
+
+          attr_reader type_params: Array[RBS::AST::TypeParam]
+
+          attr_reader super_class: RBS::AST::Declarations::Class::Super?
+
+          include Utils
+
+          # @rbs override
+          def initialize: ...
+        end
       end
     end
   end

data/sig/generated/rbs/inline/ast/comment_lines.rbs

@@ -3,7 +3,7 @@
 module RBS
   module Inline
     module AST
-      # CommentLines represents consecutive comments
+      # CommentLines represents consecutive comments, providing a mapping from locations in `#string` to a pair of a comment and its offset
       #
       # The comments construct one String.
       #
@@ -15,15 +15,19 @@ module RBS
       # We want to get a String of comment1 and comment2, `"Hello\nWorld".
       # And want to translate a location in the string into the location in comment1 and comment2.
       class CommentLines
-        attr_reader comments: Array[[ Prism::Comment, Integer ]]
+        attr_reader comments: Array[Prism::Comment]
 
         # @rbs comments: Array[Prism::Comment]
-        def initialize: (Array[Prism::Comment] comments) -> untyped
+        def initialize: (Array[Prism::Comment] comments) -> void
+
+        def lines: () -> Array[String]
 
         def string: () -> String
 
+        # Translates the cursor index of `#string` into the cursor index of a specific comment object
+        #
         # @rbs index: Integer
-        # @rbs returns [Prism::Comment, Integer]?
+        # @rbs return: [Prism::Comment, Integer]?
         def comment_location: (Integer index) -> [ Prism::Comment, Integer ]?
       end
     end