rbs 4.1.0.pre.2-java

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

data/sig/ast/ruby/declarations.rbs

@@ -0,0 +1,158 @@
+module RBS
+  module AST
+    module Ruby
+      module Declarations
+        type t = ClassDecl | ModuleDecl | ConstantDecl | ClassModuleAliasDecl
+
+        class Base
+          attr_reader buffer: Buffer
+
+          include Helpers::ConstantHelper
+          include Helpers::LocationHelper
+
+          def initialize: (Buffer) -> void
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ClassDecl < Base
+          class SuperClass
+            attr_reader operator_location: Location
+
+            attr_reader type_name_location: Location
+
+            attr_reader type_name: TypeName
+
+            attr_reader type_annotation: Annotations::TypeApplicationAnnotation?
+
+            def type_args: () -> Array[Types::t]
+
+            alias name type_name
+
+            alias args type_args
+
+            def initialize: (Location type_name_location, Location operator_location, TypeName, RBS::AST::Ruby::Annotations::TypeApplicationAnnotation?) -> void
+
+            def location: () -> Location
+
+            def type_fingerprint: () -> untyped
+          end
+
+          type member = t | Members::t
+
+          attr_reader class_name: TypeName
+
+          attr_reader node: Prism::ClassNode
+
+          attr_reader super_class: SuperClass?
+
+          attr_reader members: Array[member]
+
+          def initialize: (Buffer, TypeName, Prism::ClassNode, SuperClass?) -> void
+
+          def each_decl: () { (t) -> void } -> void
+                        | () -> Enumerator[t]
+
+          def type_params: () -> Array[AST::TypeParam]
+
+          def location: () -> Location
+
+          def name_location: () -> Location
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ModuleDecl < Base
+          type member = t | Members::t
+
+          attr_reader module_name: TypeName
+
+          attr_reader node: Prism::ModuleNode
+
+          attr_reader members: Array[member]
+
+          def initialize: (Buffer, TypeName, Prism::ModuleNode) -> void
+
+          def each_decl: () { (t) -> void } -> void
+                        | () -> Enumerator[t]
+
+          def type_params: () -> Array[AST::TypeParam]
+
+          def location: () -> Location
+
+          def self_types: () -> Array[AST::Declarations::Module::Self]
+
+          def name_location: () -> Location
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ConstantDecl < Base
+          type node = Prism::ConstantWriteNode | Prism::ConstantPathWriteNode
+
+          attr_reader leading_comment: CommentBlock?
+
+          attr_reader constant_name: TypeName
+
+          attr_reader node: node
+
+          attr_reader type_annotation: Annotations::NodeTypeAssertion?
+
+          def initialize: (Buffer, TypeName, node, CommentBlock?, Annotations::NodeTypeAssertion?) -> void
+
+          def location: () -> Location
+
+          def name_location: () -> Location
+
+          # Returns the type of the constant
+          #
+          # - When type_anntoation is given, it returns the type from the annotation.
+          # - When type_annotation is not given, it returns infered type from the right-hand-side of the constant assignment
+          # - Or it returns `untyped` type
+          #
+          def type: () -> Types::t
+
+          # Returns the comment content extracted from the leading comment block
+          #
+          def comment: () -> AST::Comment?
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ClassModuleAliasDecl < Base
+          type node = Prism::ConstantWriteNode | Prism::ConstantPathWriteNode
+
+          type annotation = Annotations::ClassAliasAnnotation | Annotations::ModuleAliasAnnotation
+
+          attr_reader node: node
+
+          attr_reader leading_comment: CommentBlock?
+
+          attr_reader new_name: TypeName
+
+          # The infered old name from the right-hand side of the constant declaration
+          #
+          # - `nil` if the annotation has the type name
+          #
+          attr_reader infered_old_name: TypeName?
+
+          attr_reader annotation: annotation
+
+          def initialize: (Buffer, node, TypeName, TypeName?, CommentBlock?, annotation) -> void
+
+          def name_location: () -> Location
+
+          def location: () -> Location
+
+          # Returns the old name of the class/module alias
+          #
+          def old_name: () -> TypeName
+
+          def comment: () -> Comment?
+
+          def type_fingerprint: () -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/helpers/constant_helper.rbs

@@ -0,0 +1,11 @@
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module ConstantHelper
+          def self?.constant_as_type_name: (Prism::node?) -> TypeName?
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/helpers/location_helper.rbs

@@ -0,0 +1,15 @@
+module RBS
+  module AST
+    module Ruby
+      module Helpers
+        module LocationHelper : _WithBuffer
+          interface _WithBuffer
+            def buffer: () -> Buffer
+          end
+          
+          def rbs_location: (Prism::Location) -> Location
+        end
+      end
+    end
+  end
+end

data/sig/ast/ruby/members.rbs

@@ -0,0 +1,198 @@
+module RBS
+  module AST
+    module Ruby
+      module Members
+        class Base
+          attr_reader buffer: Buffer
+
+          def initialize: (Buffer) -> void
+
+          include Helpers::LocationHelper
+
+          def type_fingerprint: () -> untyped
+        end
+
+        type t = DefMember
+               | IncludeMember | ExtendMember | PrependMember
+               | AttrReaderMember | AttrWriterMember | AttrAccessorMember
+               | InstanceVariableMember
+               | ModuleSelfMember
+
+        class MethodTypeAnnotation
+          class DocStyle
+            type param_type_annotation = Annotations::ParamTypeAnnotation
+                                      | Annotations::SplatParamTypeAnnotation
+                                      | Annotations::DoubleSplatParamTypeAnnotation
+                                      | Annotations::BlockParamTypeAnnotation
+
+            attr_accessor return_type_annotation: Annotations::ReturnTypeAnnotation | Annotations::NodeTypeAssertion | nil
+
+            attr_reader required_positionals: Array[Annotations::ParamTypeAnnotation | Symbol]
+            attr_reader optional_positionals: Array[Annotations::ParamTypeAnnotation | Symbol]
+            attr_accessor rest_positionals: Annotations::SplatParamTypeAnnotation | Symbol | true | nil
+            attr_reader trailing_positionals: Array[Annotations::ParamTypeAnnotation | Symbol]
+            attr_reader required_keywords: Hash[Symbol, Annotations::ParamTypeAnnotation | Symbol]
+            attr_reader optional_keywords: Hash[Symbol, Annotations::ParamTypeAnnotation | Symbol]
+            attr_accessor rest_keywords: Annotations::DoubleSplatParamTypeAnnotation | Symbol | true | nil
+            attr_accessor block: Annotations::BlockParamTypeAnnotation | Symbol | true | nil
+
+            def initialize: () -> void
+
+            def self.build: (Array[param_type_annotation], Annotations::ReturnTypeAnnotation | Annotations::NodeTypeAssertion | nil, Prism::DefNode) -> [DocStyle, Array[param_type_annotation]]
+
+            def all_param_annotations: () -> Array[param_type_annotation | Symbol | true | nil]
+
+            def map_type_name: () { (TypeName) -> TypeName } -> self
+
+            def method_type: () -> MethodType
+
+            def type_fingerprint: () -> untyped
+          end
+
+          type type_annotations = DocStyle | Array[Annotations::ColonMethodTypeAnnotation | Annotations::MethodTypesAnnotation] | nil
+
+          attr_reader type_annotations: type_annotations
+
+          def initialize: (type_annotations: type_annotations) -> void
+
+          def map_type_name: { (TypeName) -> TypeName } -> self
+
+          # Returns the method type annotations from the comment block
+          #
+          # Returns a tuple of `DefAnnotations` object, array of unused leading annotations, and unused trailing annotation.
+          #
+          def self.build: (CommentBlock? leading_block, CommentBlock? trailing_block, Array[Symbol], Prism::DefNode) -> [
+            MethodTypeAnnotation,
+            Array[Annotations::leading_annotation | CommentBlock::AnnotationSyntaxError],
+            Annotations::trailing_annotation | CommentBlock::AnnotationSyntaxError | nil
+          ]
+
+          # Returns `true` if it doesn't have any annotation
+          def empty?: () -> bool
+
+          # Returns the method type overloads
+          #
+          def overloads: () -> Array[AST::Members::MethodDefinition::Overload]
+
+          def overloading?: () -> bool
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class DefMember < Base
+          class Overload = AST::Members::MethodDefinition::Overload
+
+          attr_reader name: Symbol
+          attr_reader node: Prism::DefNode
+          attr_reader kind: :instance | :singleton
+          attr_reader method_type: MethodTypeAnnotation
+          attr_reader leading_comment: CommentBlock?
+
+          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation, CommentBlock? leading_comment, ?kind: :instance | :singleton) -> void
+
+          def singleton?: () -> bool
+
+          def instance?: () -> bool
+
+          def location: () -> Location
+
+          def overloads: () -> Array[Overload]
+
+          def overloading?: () -> bool
+
+          def annotations: () -> Array[AST::Annotation]
+
+          def name_location: () -> Location
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class MixinMember < Base
+          attr_reader node: Prism::CallNode
+
+          attr_reader module_name: TypeName
+
+          attr_reader annotation: Annotations::TypeApplicationAnnotation | nil
+
+          def initialize: (Buffer, Prism::CallNode, TypeName, Annotations::TypeApplicationAnnotation | nil) -> void
+
+          def location: () -> Location
+
+          def name_location: () -> Location
+
+          def type_args: () -> Array[Types::t]
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class IncludeMember < MixinMember
+        end
+
+        class ExtendMember < MixinMember
+        end
+
+        class PrependMember < MixinMember
+        end
+
+        class AttributeMember < Base
+          attr_reader node: Prism::CallNode
+
+          attr_reader name_nodes: Array[Prism::SymbolNode]
+
+          attr_reader type_annotation: Annotations::NodeTypeAssertion?
+
+          attr_reader leading_comment: CommentBlock?
+
+          def initialize: (Buffer, Prism::CallNode, Array[Prism::SymbolNode] name_nodes, RBS::AST::Ruby::CommentBlock? leading_comment, Annotations::NodeTypeAssertion? type_annotation) -> void
+
+          def names: () -> Array[Symbol]
+
+          def location: () -> Location
+
+          def name_locations: () -> Array[Location]
+
+          def type: () -> Types::t?
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class AttrReaderMember < AttributeMember
+        end
+
+        class AttrWriterMember < AttributeMember
+        end
+
+        class AttrAccessorMember < AttributeMember
+        end
+
+        class InstanceVariableMember < Base
+          attr_reader annotation: Annotations::InstanceVariableAnnotation
+
+          def initialize: (Buffer, Annotations::InstanceVariableAnnotation) -> void
+
+          def name: () -> Symbol
+
+          def type: () -> Types::t
+
+          def location: () -> Location
+
+          def type_fingerprint: () -> untyped
+        end
+
+        class ModuleSelfMember < Base
+          attr_reader annotation: Annotations::ModuleSelfAnnotation
+
+          def initialize: (Buffer, Annotations::ModuleSelfAnnotation) -> void
+
+          def name: () -> TypeName
+
+          def args: () -> Array[Types::t]
+
+          def location: () -> Location
+
+          def type_fingerprint: () -> untyped
+        end
+      end
+    end
+  end
+end

data/sig/buffer.rbs

@@ -0,0 +1,108 @@
+module RBS
+  class Buffer
+    # Location in a buffer.
+    # A pair of line number (1 origin) and column number (0 origin).
+    #
+    type loc = [Integer, Integer]
+
+    # Name to identify Buffer.
+    attr_reader name: Pathname
+
+    # The content of the buffer.
+    attr_reader content: String
+
+    attr_reader parent: [Buffer, Array[Range[Integer]]]?
+
+    def initialize: (name: Pathname name, content: String content) -> void
+                  | (content: String content, parent: [Buffer, Array[Range[Integer]]] parent) -> void
+
+    # Array of lines of the content, without the EOL
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: "123\nabc")
+    # buffer.lines   # => ["123", "abc"]
+    # ```
+    #
+    # If the input has EOL at the end of the file, the `lines` has an empty string at the end.
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: "123\nabc\n")
+    # buffer.lines   # => ["123", "abc", ""]
+    # ```
+    #
+    def lines: () -> Array[String]
+
+    @ranges: Array[Range[Integer]]?
+    # Array of ranges that stores the ranges of the each line, without the EOL
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: "123\nabc\n")
+    # buffer.ranges  # => [0...3, 4...7, 8...8]
+    # ```
+    #
+    def ranges: () -> Array[Range[Integer]]
+
+    # Returns the number of the lines
+    def line_count: () -> Integer
+
+    # Translate position to location.
+    def pos_to_loc: (Integer pos) -> loc
+
+    # Translate location to position.
+    def loc_to_pos: (loc loc) -> Integer
+
+    def last_position: () -> Integer
+
+    # Translate `Prism::Location` to `RBS::Location` attached to this buffer
+    #
+    # It assumes the `Prism::Location` has a source which is equivalent to `self`.
+    #
+    def rbs_location: (Prism::Location) -> Location
+                    | (Prism::Location, Prism::Location) -> Location
+
+    # Translate a byte offset (into the top buffer's source) to a character offset.
+    #
+    # Resolution is delegated to the top buffer, which keeps a sparse cache of
+    # resolved (byte, char) pairs so successive calls scan only the delta from the
+    # nearest cached pair. Amortizes to O(content_size) across all calls; a single
+    # call is one byteslice + length.
+    #
+    def character_offset: (Integer byte_offset) -> Integer
+
+    # Sparse cache backing `#character_offset`: a pair `[byte_keys, char_values]`
+    # kept in ascending byte order to support binary search.
+    @character_offset_cache: [Array[Integer], Array[Integer]]?
+
+    # Construct a buffer from substrings of this buffer.
+    #
+    # The returned buffer contains lines from given ranges.
+    #
+    # ```rb
+    # buffer = Buffer.new(name: name, content: <<TEXT)
+    # 12345
+    # abcde
+    # ABCDE
+    # TEXT
+    #
+    # buffer.sub_buffer(lines: [0...1, 2...3])  # => Buffer with content = 1\n34
+    # buffer.sub_buffer(lines: [5..7])          # => Raises an error because the range contains newline
+    # ```
+    #
+    # `byte_lines_hint:` is an optional performance hint: byte ranges corresponding
+    # to `lines:`. When provided, slicing uses `byteslice` (O(slice_size) per line)
+    # instead of `content[char_range]`, which on a multi-byte string is O(content_size)
+    # per call. Result is identical either way.
+    #
+    %a{pure} def sub_buffer: (lines: Array[Range[Integer]], ?byte_lines_hint: Array[Range[Integer]]?) -> Buffer
+
+    %a{pure} def parent_buffer: () -> Buffer?
+
+    %a{pure} def parent_position: (Integer) -> Integer?
+
+    %a{pure} def absolute_position: (Integer) -> Integer?
+
+    %a{pure} def top_buffer: () -> Buffer
+
+    %a{pure} def detach: () -> Buffer
+  end
+end

data/sig/builtin_names.rbs

@@ -0,0 +1,44 @@
+module RBS
+  module BuiltinNames
+    class Name
+      attr_reader name: TypeName
+
+      @singleton_type: Types::t?
+
+      def initialize: (name: TypeName) -> void
+
+      def to_s: () -> String
+
+      def instance_type: (*Types::t) -> Types::ClassInstance
+
+      def instance_type?: (Types::t) -> bool
+
+      def singleton_type: () -> Types::ClassSingleton
+
+      def singleton_type?: (Types::t) -> bool
+
+      def self.define: (Symbol, ?namespace: Namespace) -> instance
+    end
+
+    BasicObject: Name
+    Object: Name
+    Kernel: Name
+    String: Name
+    Comparable: Name
+    Enumerable: Name
+    Class: Name
+    Module: Name
+    Array: Name
+    Hash: Name
+    Range: Name
+    Enumerator: Name
+    Set: Name
+    Symbol: Name
+    Integer: Name
+    Float: Name
+    Regexp: Name
+    TrueClass: Name
+    FalseClass: Name
+    Numeric: Name
+  end
+end

data/sig/cli/colored_io.rbs

@@ -0,0 +1,15 @@
+module RBS
+  class CLI
+    class ColoredIO
+      attr_reader stdout: CLI::_IO
+      def initialize: (stdout: CLI::_IO) -> void
+      def puts_green: (String) -> void
+      def puts_red: (String) -> void
+      def puts: (?String) -> void
+
+      private def can_display_colors?: () -> bool
+      private def are_colors_supported?: () -> bool
+      private def are_colors_disabled?: () -> bool
+    end
+  end
+end

data/sig/cli/diff.rbs

@@ -0,0 +1,15 @@
+module RBS
+  class CLI
+    class Diff
+      @stdout: _IO
+      @stderr: _IO
+
+      def initialize: (?stdout: _IO, ?stderr: _IO) -> void
+
+      def run: (library_options: RBS::CLI::LibraryOptions, argv: Array[String]) -> Integer
+
+      def run_diff: (RBS::Diff) -> void
+      def run_markdown: (RBS::Diff) -> void
+    end
+  end
+end