rbs 3.9.4 → 4.2.0

data/sig/ast/ruby/annotations.rbs

@@ -0,0 +1,470 @@
+module RBS
+  module AST
+    module Ruby
+      module Annotations
+        type leading_annotation = ColonMethodTypeAnnotation
+                                | MethodTypesAnnotation
+                                | SkipAnnotation
+                                | ReturnTypeAnnotation
+                                | InstanceVariableAnnotation
+                                | ModuleSelfAnnotation
+                                | ParamTypeAnnotation
+                                | SplatParamTypeAnnotation
+                                | DoubleSplatParamTypeAnnotation
+                                | BlockParamTypeAnnotation
+
+        type trailing_annotation = NodeTypeAssertion
+                                 | TypeApplicationAnnotation
+                                 | ClassAliasAnnotation
+                                 | ModuleAliasAnnotation
+
+        type t = leading_annotation | trailing_annotation
+
+        class Base
+          # Location that covers all of the annotation
+          #
+          attr_reader location: Location
+
+          # Location of `@rbs`, `@rbs!`, or `:` prefix
+          #
+          attr_reader prefix_location: Location
+
+          def initialize: (Location location, Location prefix_location) -> void
+
+          def buffer: () -> Buffer
+
+          # Returns the type fingerprint for this annotation
+          def type_fingerprint: () -> untyped
+        end
+
+        # `: TYPE` annotation attached to nodes
+        #
+        class NodeTypeAssertion < Base
+          attr_reader type: Types::t
+
+          def initialize: (location: Location, prefix_location: Location, type: Types::t) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class AliasAnnotation < Base
+          attr_reader keyword_location: Location
+
+          attr_reader type_name_location: Location?
+
+          # The name of the module that will be the target of the alias
+          #
+          # - `nil` if the module/class name is unspecified
+          # - `TypeName` object if the module/class name is specified
+          #
+          attr_reader type_name: TypeName?
+
+          def initialize: (location: Location, prefix_location: Location, keyword_location: Location, type_name: TypeName?, type_name_location: Location?) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+        end
+
+        # `: class-alias` annotation
+        #
+        # ```
+        # : class-alias Foo::Bar
+        # ^                        -- prefix_location
+        #   ^^^^^^^^^^^^           -- keyword_location
+        #                ^^^^^^^^  -- type_name_location
+        # ```
+        #
+        class ClassAliasAnnotation < AliasAnnotation
+          def type_fingerprint: () -> untyped
+        end
+
+        # `: module-alias` annotation
+        #
+        # ```
+        # : module-alias Foo::Bar
+        # ^                        -- prefix_location
+        #   ^^^^^^^^^^^^           -- keyword_location
+        #                ^^^^^^^^  -- type_name_location
+        # ```
+        #
+        class ModuleAliasAnnotation < AliasAnnotation
+          def type_fingerprint: () -> untyped
+        end
+
+        # `: METHOD-TYPE` annotation in leading comments
+        #
+        class ColonMethodTypeAnnotation < Base
+          attr_reader annotations: Array[AST::Annotation]
+
+          attr_reader method_type: MethodType
+
+          def initialize: (location: Location, prefix_location: Location, annotations: Array[AST::Annotation], method_type: MethodType) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs METHOD-TYPEs` annotation in leading comments
+        #
+        # ```
+        # @rbs () -> void | %a{foo} () -> String | ...
+        # ^^^^                                            -- prefix_location
+        #                 ^                               -- vertical_bar_locations[0]
+        #                                        ^        -- vertical_bar_locations[1]
+        #                                          ^^^    -- dot3_location
+        # ```
+        class MethodTypesAnnotation < Base
+          class Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader overloads: Array[Overload]
+
+          attr_reader vertical_bar_locations: Array[Location]
+
+          attr_reader dot3_location: Location?
+
+          def initialize: (location: Location, prefix_location: Location, overloads: Array[Overload], vertical_bar_locations: Array[Location], dot3_location: Location?) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs skip -- comment` annotation in leading comments
+        #
+        class SkipAnnotation < Base
+          attr_reader skip_location: Location
+          attr_reader comment_location: Location?
+
+          def initialize: (location: Location, prefix_location: Location, skip_location: Location, comment_location: Location?) -> void
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs return: T -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs return: String -- Returns a string
+        # ^^^                                        -- prefix_location
+        #      ^^^^^^                                -- return_location
+        #            ^                               -- colon_location
+        #                     ^^^^^^^^^^^^^^^^^^^    -- comment
+        # ```
+        class ReturnTypeAnnotation < Base
+          attr_reader return_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader return_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            return_location: Location,
+            colon_location: Location,
+            return_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `[T1, T2, ...]` annotation in trailing comments
+        #
+        # ```
+        # #[String, Integer]
+        #  ^                     -- prefix_location
+        #         ^              -- comma_locations[0]
+        #                  ^     -- close_bracket_location
+        # ```
+        #
+        class TypeApplicationAnnotation < Base
+          attr_reader type_args: Array[Types::t]
+
+          attr_reader close_bracket_location: Location
+
+          attr_reader comma_locations: Array[Location]
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            type_args: Array[Types::t],
+            close_bracket_location: Location,
+            comma_locations: Array[Location],
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs IVAR-NAME : TYPE` annotation in leading comments
+        #
+        # ```
+        # @rbs @foo : String -- comment
+        # ^^^^                             -- prefix_location
+        #      ^^^^                        -- ivar_name_location
+        #           ^                      -- colon_location
+        #                    ^^^^^^^^^^    -- comment_location
+        # ```
+        class InstanceVariableAnnotation < Base
+          attr_reader ivar_name: Symbol
+
+          attr_reader ivar_name_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            ivar_name: Symbol,
+            ivar_name_location: Location,
+            colon_location: Location,
+            type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        # `@rbs module-self: NAME[ARGS] -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs module-self: _Each[String, Integer] -- comment
+        # ^^^^                                                -- prefix_location
+        #      ^^^^^^^^^^^                                    -- keyword_location
+        #                 ^                                   -- colon_location
+        #                        ^                            -- open_bracket_location
+        #                               ^                     -- args_comma_locations[0]
+        #                                        ^            -- close_bracket_location
+        #                                          ^^^^^^^^^^ -- comment_location
+        # ```
+        #
+        class ModuleSelfAnnotation < Base
+          attr_reader keyword_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader name: TypeName
+
+          attr_reader args: Array[Types::t]
+
+          attr_reader open_bracket_location: Location?
+
+          attr_reader close_bracket_location: Location?
+
+          attr_reader args_comma_locations: Array[Location]
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            keyword_location: Location,
+            colon_location: Location,
+            name: TypeName,
+            args: Array[Types::t],
+            open_bracket_location: Location?,
+            close_bracket_location: Location?,
+            args_comma_locations: Array[Location],
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ParamTypeAnnotation < Base
+          attr_reader name_location: Location
+
+          attr_reader colon_location: Location
+
+          attr_reader param_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            name_location: Location,
+            colon_location: Location,
+            param_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure}
+          def name: () -> Symbol
+        end
+
+        # `@rbs *name: Type -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs *a: String -- comment
+        # ^^^^                         -- prefix_location
+        #      ^                       -- star_location
+        #       ^                      -- name_location
+        #        ^                     -- colon_location
+        #                 ^^^^^^^^^^   -- comment_location
+        # ```
+        #
+        # ```
+        # @rbs *: String
+        # ^^^^             -- prefix_location
+        #      ^           -- star_location
+        #       ^          -- colon_location
+        # ```
+        #
+        class SplatParamTypeAnnotation < Base
+          attr_reader star_location: Location
+
+          attr_reader name_location: Location?
+
+          attr_reader colon_location: Location
+
+          attr_reader param_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            star_location: Location,
+            name_location: Location?,
+            colon_location: Location,
+            param_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure}
+          def name: () -> Symbol?
+        end
+
+        # `@rbs **name: Type -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs **b: bool -- comment
+        # ^^^^                        -- prefix_location
+        #      ^^                     -- star2_location
+        #        ^                    -- name_location
+        #         ^                   -- colon_location
+        #                 ^^^^^^^^^^  -- comment_location
+        # ```
+        #
+        # ```
+        # @rbs **: bool
+        # ^^^^            -- prefix_location
+        #      ^^         -- star2_location
+        #        ^        -- colon_location
+        # ```
+        #
+        class DoubleSplatParamTypeAnnotation < Base
+          attr_reader star2_location: Location
+
+          attr_reader name_location: Location?
+
+          attr_reader colon_location: Location
+
+          attr_reader param_type: Types::t
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            star2_location: Location,
+            name_location: Location?,
+            colon_location: Location,
+            param_type: Types::t,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure}
+          def name: () -> Symbol?
+        end
+
+        # `@rbs &name: TYPE -- comment` annotation in leading comments
+        #
+        # ```
+        # @rbs &block: () -> void -- comment
+        # ^^^^                               -- prefix_location
+        #      ^                             -- ampersand_location
+        #       ^^^^^                        -- name_location
+        #            ^                       -- colon_location
+        #              ^^^^^^^^^^            -- type_location
+        #                         ^^^^^^^^^^ -- comment_location
+        # ```
+        #
+        # ```
+        # @rbs &: ? () -> void
+        # ^^^^                 -- prefix_location
+        #      ^               -- ampersand_location
+        #       ^              -- colon_location
+        #         ^            -- question_location
+        #           ^^^^^^^^^^ -- type_location
+        # ```
+        #
+        class BlockParamTypeAnnotation < Base
+          attr_reader ampersand_location: Location
+
+          attr_reader name_location: Location?
+
+          attr_reader colon_location: Location
+
+          attr_reader type_location: Location
+
+          attr_reader type: Types::function
+
+          attr_reader question_location: Location?
+
+          attr_reader comment_location: Location?
+
+          def initialize: (
+            location: Location,
+            prefix_location: Location,
+            ampersand_location: Location,
+            name_location: Location?,
+            colon_location: Location,
+            question_location: Location?,
+            type_location: Location,
+            type: Types::function,
+            comment_location: Location?,
+          ) -> void
+
+          def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
+
+          %a{pure} def name: () -> Symbol?
+
+          def optional?: () -> bool
+
+          def required?: () -> bool
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/comment_block.rbs

@@ -0,0 +1,127 @@
+use Prism::Comment
+
+module RBS
+  module AST
+    module Ruby
+      # CommentBlock is a collection of comments
+      #
+      # ```ruby
+      # # Comment1      < block1
+      # # Comment2      <
+      #
+      # # Comment3      < block2
+      # ```
+      #
+      # A comment block is a *leading* block or *trailing* block.
+      #
+      # ```ruby
+      # # This is leading block.
+      # # This is the second line of the leading block.
+      #
+      # foo      # This is trailing block.
+      #          # This is second line of the trailing block.
+      # ```
+      #
+      # A leading block is a comment block where all of the comments are at the start of the line content.
+      # A trailing block is a comment block where the first comment of the block has something at the line before the comment.
+      #
+      class CommentBlock
+        attr_reader name: Pathname
+
+        # Sub buffer of the contents of the comments
+        #
+        attr_reader comment_buffer: Buffer
+
+        attr_reader offsets: Array[
+          [
+            Comment,
+            Integer, # -- prefix size
+          ]
+        ]
+
+        def initialize: (Buffer source_buffer, Array[Comment]) -> void
+
+        # Build comment block instances
+        def self.build: (Buffer, Array[Comment]) -> Array[instance]
+
+        # Returns true if the comment block is a *leading* comment, which is attached to the successor node
+        def leading?: () -> bool
+
+        # Returns true if the comment block is a *trailing* comment, which is attached to the predecessor node
+        def trailing?: () -> bool
+
+        # The line number of the first comment in the block
+        def start_line: () -> Integer
+
+        # The line number of the last comment in the block
+        def end_line: () -> Integer
+
+        # The character index of `#comment_buffer` at the start of the lines
+        #
+        def line_starts: () -> Array[Integer]
+
+        # Returns the text content of the comment
+        def text: (Integer index) -> String
+
+        # Yields paragraph and annotation
+        #
+        # A paragraph is a sequence of lines that are separated by annotations.
+        # An annotation starts with a line starting with `@rbs` or `:`, and may continue with lines that has more leading spaces.
+        #
+        # ```
+        # # Line 1         ^ Paragraph 1
+        # #   Line 2       |
+        # #                |
+        # # Line 3         v
+        # # @rbs ...       < Annotation 1
+        # # @rbs ...       ^ Annotation 2
+        # #   ...          |
+        # #                |
+        # #   ...          v
+        # #                ^ Paragraph 2
+        # # Line 4         |
+        # # Line 5         v
+        # ```
+        #
+        def each_paragraph: (Array[Symbol] variables) { (Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError) -> void } -> void
+                          | (Array[Symbol] variables) -> Enumerator[Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError]
+
+        # Returns a trailing annotation if it exists
+        #
+        # * Returns `nil` if the block is not a type annotation
+        # * Returns an annotation if the block has a type annotation
+        # * Returns AnnotationSyntaxError if the annotation has a syntax error
+        #
+        def trailing_annotation: (Array[Symbol] variables) -> (AST::Ruby::Annotations::trailing_annotation | AnnotationSyntaxError | nil)
+
+        class AnnotationSyntaxError
+          attr_reader location: Location
+
+          attr_reader error: ParsingError
+
+          def initialize: (Location, ParsingError) -> void
+        end
+
+        private def yield_paragraph: (Integer start_line, Integer current_line, Array[Symbol] variables) { (Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError) -> void } -> void
+
+        private def yield_annotation: (Integer start_line, Integer end_line, Integer current_line, Array[Symbol] variables) { (Location | AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError) -> void } -> void
+
+        private def parse_annotation_lines: (Integer start_line, Integer end_line, Array[Symbol] variables) -> (AST::Ruby::Annotations::leading_annotation | AnnotationSyntaxError)
+
+        def comments: () -> Array[Comment]
+
+        def line_location: (Integer start_line, Integer end_line) -> Location
+
+        def location: () -> Location
+
+        private def leading_annotation?: (Integer index) -> bool
+
+        # Returns an comment object that contains the docs of from the comment block
+        #
+        # It ignores type annotations and syntax errors.
+        # 
+        def as_comment: () -> AST::Comment?
+      end
+    end
+  end
+end