rbs-inline 0.4.0 → 0.6.0

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

@@ -0,0 +1,221 @@
+# Generated from lib/rbs/inline/annotation_parser/tokenizer.rb with RBS::Inline
+
+module RBS
+  module Inline
+    class AnnotationParser
+      module Tokens
+        K_RETURN: ::Symbol
+
+        K_INHERITS: ::Symbol
+
+        K_AS: ::Symbol
+
+        K_OVERRIDE: ::Symbol
+
+        K_USE: ::Symbol
+
+        K_MODULE_SELF: ::Symbol
+
+        K_GENERIC: ::Symbol
+
+        K_IN: ::Symbol
+
+        K_OUT: ::Symbol
+
+        K_UNCHECKED: ::Symbol
+
+        K_SELF: ::Symbol
+
+        K_SKIP: ::Symbol
+
+        K_YIELDS: ::Symbol
+
+        K_MODULE: ::Symbol
+
+        K_CLASS: ::Symbol
+
+        K_COLON2: ::Symbol
+
+        K_COLON: ::Symbol
+
+        K_LBRACKET: ::Symbol
+
+        K_RBRACKET: ::Symbol
+
+        K_COMMA: ::Symbol
+
+        K_STAR2: ::Symbol
+
+        K_STAR: ::Symbol
+
+        K_MINUS2: ::Symbol
+
+        K_LT: ::Symbol
+
+        K_DOT3: ::Symbol
+
+        K_DOT: ::Symbol
+
+        K_ARROW: ::Symbol
+
+        K_LBRACE: ::Symbol
+
+        K_LPAREN: ::Symbol
+
+        K_AMP: ::Symbol
+
+        K_QUESTION: ::Symbol
+
+        K_VBAR: ::Symbol
+
+        K_EOF: ::Symbol
+
+        # `@rbs!`
+        K_RBSE: ::Symbol
+
+        # `@rbs`
+        K_RBS: ::Symbol
+
+        T_UIDENT: ::Symbol
+
+        T_IFIDENT: ::Symbol
+
+        T_LVAR: ::Symbol
+
+        # The body of comment string following `--`
+        T_COMMENT: ::Symbol
+
+        # Type/method type source
+        T_SOURCE: ::Symbol
+
+        # Block type source
+        T_BLOCKSTR: ::Symbol
+
+        # `!` local variable
+        T_ELVAR: ::Symbol
+
+        T_ATIDENT: ::Symbol
+
+        T_ANNOTATION: ::Symbol
+
+        T_WHITESPACE: ::Symbol
+      end
+
+      class Tokenizer
+        include Tokens
+
+        KEYWORDS: Hash[String, Symbol]
+
+        KW_RE: ::Regexp
+
+        PUNCTS: Hash[String, Symbol]
+
+        PUNCTS_RE: Regexp
+
+        attr_reader scanner: StringScanner
+
+        # Tokens that comes after the current position
+        #
+        # This is a four tuple of tokens.
+        #
+        # 1. The first array is a trivia tokens before current position
+        # 2. The second token is the first lookahead token after the current position
+        # 3. The third array is a trivia tokens between the first lookahead and the second lookahead
+        # 4. The fourth token is the second lookahead token
+        attr_reader lookahead_tokens: [ Array[token], token?, Array[token], token? ]
+
+        # Token that comes after the current position
+        # @rbs %a{pure}
+        %a{pure}
+        def lookahead1: () -> token?
+
+        # Token that comes after `lookahead1`
+        # @rbs %a{pure}
+        %a{pure}
+        def lookahead2: () -> token?
+
+        # Returns the current char position of the first lookahead token
+        #
+        # ```
+        # __ foo ___ bar baz
+        # ^^                 Trivia tokens before lookahead1
+        #   ^                #current_position
+        #    ^^^             lookahead1
+        #        ^^^         Trivia tokens between lookahead1 and lookahead2
+        #            ^^^     lookahead2
+        #                ^    <= scanner.charpos
+        # ```
+        def current_position: () -> Integer
+
+        def lookaheads: () -> Array[Symbol?]
+
+        # @rbs scanner: StringScanner
+        # @rbs return: void
+        def initialize: (StringScanner scanner) -> void
+
+        # Advances the scanner
+        #
+        # @rbs tree: AST::Tree -- Tree to insert trivia tokens
+        # @rbs eat: bool -- true to add the current lookahead token into the tree
+        # @rbs return: void
+        def advance: (AST::Tree tree, ?eat: bool) -> void
+
+        # @rbs (AST::Tree?) -> String
+        def consume_trivias: (AST::Tree?) -> String
+
+        # Returns true if the scanner cannot consume next token
+        def stuck?: () -> bool
+
+        # Skips characters
+        #
+        # This method ensures the `current_position` will be the given `position`.
+        #
+        # @rbs position: Integer -- The new position
+        # @rbs tree: AST::Tree -- Tree to insert trivia tokens
+        # @rbs return: void
+        def reset: (Integer position, AST::Tree tree) -> void
+
+        def rest: () -> String
+
+        # Consume given token type and inserts the token to the tree or `nil`
+        #
+        # @rbs *types: Symbol
+        # @rbs tree: AST::Tree
+        # @rbs return: void
+        def consume_token: (*Symbol types, tree: AST::Tree) -> void
+
+        # Consume given token type and inserts the token to the tree or raise
+        #
+        # @rbs *types: Symbol
+        # @rbs tree: AST::Tree
+        # @rbs return: void
+        def consume_token!: (*Symbol types, tree: AST::Tree) -> void
+
+        # Test if current token has specified `type`
+        #
+        # @rbs *types: Symbol
+        # @rbs return: bool
+        def type?: (*Symbol types) -> bool
+
+        # Test if lookahead2 token have specified `type`
+        #
+        # @rbs *types: Symbol -- The type of the lookahead2 token
+        # @rbs return: bool
+        def type2?: (*Symbol types) -> bool
+
+        # Ensure current token is one of the specified in types
+        #
+        # @rbs *types: Symbol
+        # @rbs return: void
+        def type!: (*Symbol types) -> void
+
+        # Reset the current_token to incoming comment `--`
+        #
+        # Reset to the end of the input if `--` token cannot be found.
+        #
+        # @rbs return: String -- String that is skipped
+        def skip_to_comment: () -> String
+      end
+    end
+  end
+end

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