rbs 3.10.4 → 4.0.0

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,178 @@
+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
+
+        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 method_type: MethodTypeAnnotation
+          attr_reader leading_comment: CommentBlock?
+
+          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation, CommentBlock? leading_comment) -> void
+
+          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
+      end
+    end
+  end
+end

data/sig/buffer.rbs

@@ -6,21 +6,45 @@ module RBS
     type loc = [Integer, Integer]
 
     # Name to identify Buffer.
-    attr_reader name: untyped
+    attr_reader name: Pathname
 
     # The content of the buffer.
     attr_reader content: String
 
-    @lines: Array[String]
+    attr_reader parent: [Buffer, Array[Range[Integer]]]?
 
-    @ranges: Array[Range[Integer]]
-
-    def initialize: (name: untyped name, content: String content) -> void
+    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
 
@@ -28,5 +52,39 @@ module RBS
     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
+
+    # 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
+    # ```
+    #
+    %a{pure} def sub_buffer: (lines: 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/cli/diff.rbs

@@ -1,21 +1,15 @@
 module RBS
   class CLI
     class Diff
-      @format: String
       @stdout: _IO
       @stderr: _IO
-      @diff: RBS::Diff
 
-      def initialize: (
-        argv: Array[String],
-        library_options: RBS::CLI::LibraryOptions,
-        ?stdout: _IO,
-        ?stderr: _IO,
-      ) -> void
+      def initialize: (?stdout: _IO, ?stderr: _IO) -> void
 
-      def run: () -> void
-      def run_diff: () -> void
-      def run_markdown: () -> 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

data/sig/cli/validate.rbs

@@ -3,15 +3,22 @@ module RBS
     class Validate
       class Errors
         @limit: Integer?
-        @exit_error: boolish
-        @has_syntax_error: bool
         @errors: Array[BaseError]
 
-        def initialize: (limit: Integer?, exit_error: boolish) -> void
+        # The tag that will be thrown in #finish method
+        @tag: top
+
+        def initialize: (limit: Integer?) -> void
 
         def add: (BaseError) -> void
 
-        def finish: () -> void
+        # Throws the `@tag` with 0 or 1
+        #
+        # Must be called from the block passed to `#try` method.
+        #
+        def finish: () -> Integer
+
+        def try: () { () -> void } -> Integer
 
         private
 
@@ -25,7 +32,7 @@ module RBS
 
       def initialize: (args: Array[String], options: LibraryOptions) -> void
 
-      def run: () -> void
+      def run: () -> Integer
 
       private
 
@@ -35,9 +42,6 @@ module RBS
       def validate_constant: () -> void
       def validate_global: () -> void
       def validate_type_alias: () -> void
-      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
-      def no_classish_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
-      def void_type_context_validator: (::RBS::Types::t | ::RBS::MethodType type, ?bool allowed_here) -> void
     end
   end
 end

data/sig/cli.rbs

@@ -46,41 +46,41 @@ module RBS
 
     def has_parser?: () -> bool
 
-    def run: (Array[String] args) -> void
+    def run: (Array[String] args) -> Integer
 
-    def run_ast: (Array[String], LibraryOptions) -> void
+    def run_ast: (Array[String], LibraryOptions) -> Integer
 
-    def run_list: (Array[String], LibraryOptions) -> void
+    def run_list: (Array[String], LibraryOptions) -> Integer
 
-    def run_ancestors: (Array[String], LibraryOptions) -> void
+    def run_ancestors: (Array[String], LibraryOptions) -> Integer
 
-    def run_methods: (Array[String], LibraryOptions) -> void
+    def run_methods: (Array[String], LibraryOptions) -> Integer
 
-    def run_method: (Array[String], LibraryOptions) -> void
+    def run_method: (Array[String], LibraryOptions) -> Integer
 
-    def run_validate: (Array[String], LibraryOptions) -> void
+    def run_validate: (Array[String], LibraryOptions) -> Integer
 
-    def run_constant: (Array[String], LibraryOptions) -> void
+    def run_constant: (Array[String], LibraryOptions) -> Integer
 
-    def run_paths: (Array[String], LibraryOptions) -> void
+    def run_paths: (Array[String], LibraryOptions) -> Integer
 
-    def run_prototype: (Array[String], LibraryOptions) -> void
+    def run_prototype: (Array[String], LibraryOptions) -> Integer
 
-    def run_prototype_file: (String format, Array[String]) -> void
+    def run_prototype_file: (String format, Array[String]) -> Integer
 
-    def run_vendor: (Array[String], LibraryOptions) -> void
+    def run_vendor: (Array[String], LibraryOptions) -> Integer
 
-    def run_parse: (Array[String], LibraryOptions) -> void
+    def run_parse: (Array[String], LibraryOptions) -> Integer
 
-    def run_test: (Array[String], LibraryOptions) -> void
+    def run_test: (Array[String], LibraryOptions) -> Integer
 
-    def run_collection: (Array[String], LibraryOptions) -> void
+    def run_collection: (Array[String], LibraryOptions) -> Integer
 
-    def run_annotate: (Array[String], top) -> void
+    def run_annotate: (Array[String], top) -> Integer
 
-    def run_subtract: (Array[String], top) -> void
+    def run_subtract: (Array[String], top) -> Integer
 
-    def run_diff: (Array[String], LibraryOptions) -> void
+    def run_diff: (Array[String], LibraryOptions) -> Integer
 
     def test_opt: (LibraryOptions) -> String?
 

data/sig/definition.rbs

@@ -12,6 +12,10 @@ module RBS
                   | AST::Members::InstanceVariable
                   | AST::Members::ClassVariable
                   | AST::Members::ClassInstanceVariable
+                  | AST::Ruby::Members::AttrReaderMember
+                  | AST::Ruby::Members::AttrWriterMember
+                  | AST::Ruby::Members::AttrAccessorMember
+                  | AST::Ruby::Members::InstanceVariableMember
       attr_reader source: source
 
       def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName, source: source) -> void
@@ -21,6 +25,7 @@ module RBS
 
     class Method
       type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
+                         | AST::Ruby::Members::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
 
       class TypeDef
         attr_reader type: MethodType
@@ -154,6 +159,7 @@ module RBS
         type source = :super     # Inheritance
                     | nil        # Itself
                     | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend  # AST
+                    | AST::Ruby::Members::IncludeMember | AST::Ruby::Members::ExtendMember | AST::Ruby::Members::PrependMember  # Ruby AST
                     | AST::Declarations::Module::Self
 
         attr_reader name: TypeName

data/sig/definition_builder.rbs

@@ -97,13 +97,15 @@ module RBS
     #
     def interface_methods: (Array[Definition::Ancestor::Instance] interface_ancestors) -> interface_methods
 
+    def special_accessibility: (bool, Symbol) -> Definition::accessibility?
+
     def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
 
     def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
 
     def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
 
-    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
+    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t | AST::Ruby::Declarations::t) -> Location[untyped, untyped]?
 
     def validate_variable: (Definition::Variable) -> void
 

data/sig/environment/class_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ClassEntry.new(TypeName.parse("::String"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Kernel")], declaration]
+    # ```
+    class ClassEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Class | AST::Ruby::Declarations::ClassDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      @primary_decl: declaration?
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Find the *primary* declaration of the class
+      #
+      # * Returns the first declaration with super class
+      # * Returns the first declaration if the declaration doesn't have super class
+      #
+      %a{pure} def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+    end
+  end
+end

data/sig/environment/module_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ModuleEntry.new(TypeName.parse("::Kernel"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Object")], declaration]
+    # ```
+    #
+    class ModuleEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Module | AST::Ruby::Declarations::ModuleDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Returns the first declaration
+      #
+      # This method helps using the class with `ClassEntry` objects.
+      #
+      def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+
+      def self_types: () -> Array[AST::Declarations::Module::Self]
+    end
+  end
+end