rbs 4.0.0.dev.4 → 4.0.0.dev.5

data/sig/ast/ruby/annotations.rbs

@@ -6,8 +6,12 @@ module RBS
                                 | MethodTypesAnnotation
                                 | SkipAnnotation
                                 | ReturnTypeAnnotation
+                                | InstanceVariableAnnotation
 
         type trailing_annotation = NodeTypeAssertion
+                                 | TypeApplicationAnnotation
+                                 | ClassAliasAnnotation
+                                 | ModuleAliasAnnotation
 
         type t = leading_annotation | trailing_annotation
 
@@ -23,6 +27,9 @@ module RBS
           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
@@ -33,6 +40,51 @@ module RBS
           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
@@ -45,6 +97,8 @@ module RBS
           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
@@ -64,6 +118,8 @@ module RBS
           def initialize: (location: Location, prefix_location: Location, overloads: Array[Overload], vertical_bar_locations: Array[Location]) -> void
 
           def map_type_name: () { (TypeName) -> TypeName } -> self
+
+          def type_fingerprint: () -> untyped
         end
 
         # `@rbs skip -- comment` annotation in leading comments
@@ -73,6 +129,8 @@ module RBS
           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
@@ -103,6 +161,72 @@ module RBS
           ) -> 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
       end
     end

data/sig/ast/ruby/comment_block.rbs

@@ -112,7 +112,15 @@ module RBS
 
         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

data/sig/ast/ruby/declarations.rbs

@@ -2,7 +2,7 @@ module RBS
   module AST
     module Ruby
       module Declarations
-        type t = ClassDecl | ModuleDecl
+        type t = ClassDecl | ModuleDecl | ConstantDecl | ClassModuleAliasDecl
 
         class Base
           attr_reader buffer: Buffer
@@ -11,27 +11,55 @@ module RBS
           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) -> void
+          def initialize: (Buffer, TypeName, Prism::ClassNode, SuperClass?) -> void
 
           def each_decl: () { (t) -> void } -> void
                         | () -> Enumerator[t]
 
-          def super_class: () -> nil
-
           def type_params: () -> Array[AST::TypeParam]
 
           def location: () -> Location
+
+          def name_location: () -> Location
+
+          def type_fingerprint: () -> untyped
         end
 
         class ModuleDecl < Base
@@ -53,6 +81,76 @@ module RBS
           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

data/sig/ast/ruby/members.rbs

@@ -8,9 +8,14 @@ module RBS
           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
@@ -21,6 +26,8 @@ module RBS
             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
@@ -47,6 +54,8 @@ module RBS
           # Returns the method type overloads
           #
           def overloads: () -> Array[AST::Members::MethodDefinition::Overload]
+
+          def type_fingerprint: () -> untyped
         end
 
         class DefMember < Base
@@ -55,8 +64,9 @@ module RBS
           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) -> void
+          def initialize: (Buffer, Symbol name, Prism::DefNode node, MethodTypeAnnotation, CommentBlock? leading_comment) -> void
 
           def location: () -> Location
 
@@ -65,6 +75,82 @@ module RBS
           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

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

@@ -7,11 +7,20 @@ module RBS
         @has_syntax_error: bool
         @errors: Array[BaseError]
 
+        # The tag that will be thrown in #finish method
+        @tag: top
+
         def initialize: (limit: Integer?, exit_error: boolish) -> 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 +34,7 @@ module RBS
 
       def initialize: (args: Array[String], options: LibraryOptions) -> void
 
-      def run: () -> void
+      def run: () -> Integer
 
       private
 
@@ -35,9 +44,9 @@ 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
+      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
+      %a{deprecated} 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,7 +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::DefMember | AST::Ruby::Members::AttrReaderMember | AST::Ruby::Members::AttrWriterMember | AST::Ruby::Members::AttrAccessorMember
 
       class TypeDef
         attr_reader type: MethodType
@@ -155,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