rbs-inline 0.4.0 → 0.6.0

data/sig/generated/rbs/inline/ast/annotations.rbs

@@ -4,7 +4,24 @@ module RBS
   module Inline
     module AST
       module Annotations
-        type t = VarType | ReturnType | Use | Inherits | Generic | ModuleSelf | Skip | Assertion | Application | RBSAnnotation | Override | IvarType | Yields | Embedded
+        type t = VarType | ReturnType | Use | Inherits | Generic | ModuleSelf | Skip | MethodTypeAssertion | TypeAssertion | SyntaxErrorAssertion | Dot3Assertion | Application | RBSAnnotation | Override | IvarType | Embedded | Method | SplatParamType | DoubleSplatParamType | BlockType | ModuleDecl | ClassDecl
+
+        module Utils
+          # @rbs (Tree) -> RBS::AST::TypeParam?
+          def translate_type_param: (Tree) -> RBS::AST::TypeParam?
+
+          # @rbs (Types::t) -> RBS::AST::Declarations::Class::Super?
+          def translate_super_class: (Types::t) -> RBS::AST::Declarations::Class::Super?
+
+          # Assumes the tree is generated through `#parse_module_name`
+          #
+          # Returns a type name, or `nil` if the tree is something invalid.
+          #
+          # @param tree -- A tree object that is generated through `#parse_module_name`
+          #
+          # @rbs (AST::Tree) -> TypeName?
+          def translate_type_name: (AST::Tree) -> TypeName?
+        end
 
         class Base
           attr_reader source: CommentLines
@@ -13,7 +30,7 @@ module RBS
 
           # @rbs tree: Tree
           # @rbs source: CommentLines
-          # @rbs returns void
+          # @rbs return: void
           def initialize: (Tree tree, CommentLines source) -> void
         end
 
@@ -27,11 +44,46 @@ module RBS
           # @rbs override
           def initialize: ...
 
-          # :: () -> bool
+          # : () -> bool
           def complete?: () -> bool
         end
 
-        # `@rbs returns T`
+        class SpecialVarTypeAnnotation < Base
+          attr_reader name: Symbol?
+
+          attr_reader type: Types::t?
+
+          attr_reader comment: String?
+
+          attr_reader type_source: String
+
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `@rbs *x: T`
+        class SplatParamType < SpecialVarTypeAnnotation
+        end
+
+        # `@rbs` **x: T
+        class DoubleSplatParamType < SpecialVarTypeAnnotation
+        end
+
+        # `@rbs &block: METHOD-TYPE` or `@rbs &block: ? METHOD-TYPE`
+        class BlockType < Base
+          attr_reader name: Symbol?
+
+          attr_reader type: Types::Block?
+
+          attr_reader comment: String?
+
+          attr_reader type_source: String
+
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `@rbs return: T`
         class ReturnType < Base
           attr_reader type: Types::t?
 
@@ -40,7 +92,7 @@ module RBS
           # @rbs override
           def initialize: ...
 
-          # @rbs returns bool
+          # @rbs return: bool
           def complete?: () -> bool
         end
 
@@ -58,53 +110,45 @@ module RBS
           def initialize: ...
         end
 
-        # `#:: TYPE`
-        class Assertion < Base
-          attr_reader type: Types::t | MethodType | nil
-
-          def initialize: (untyped tree, untyped source) -> untyped
-
-          # @rbs returns bool
-          def complete?: () -> bool
+        class MethodTypeAssertion < Base
+          attr_reader method_type: MethodType
 
-          # Returns a type if it's type
-          def type?: () -> Types::t?
+          # @rbs override
+          def initialize: ...
 
-          # Returns a method type if it's a method type
-          def method_type?: () -> MethodType?
+          def type_source: () -> String
         end
 
-        # `#[TYPE, ..., TYPE]`
-        class Application < Base
-          attr_reader types: Array[Types::t]?
+        class TypeAssertion < Base
+          attr_reader type: Types::t
 
           # @rbs override
           def initialize: ...
 
-          # @rbs returns bool
-          def complete?: () -> bool
+          def type_source: () -> String
         end
 
-        # `# @rbs yields () -> void -- Comment`
-        class Yields < Base
-          # The type of block
-          #
-          # * Types::Block when syntactically correct input is given
-          # * String when syntax error is reported
-          # * `nil` when nothing is given
-          attr_reader block_type: Types::Block | String | nil
+        class SyntaxErrorAssertion < Base
+          attr_reader error_string: String
 
-          # The content of the comment or `nil`
-          attr_reader comment: String?
+          # @rbs override
+          def initialize: ...
+        end
 
-          # If `[optional]` token is inserted just after `yields` token
-          #
-          # The Types::Block instance has correct `required` attribute based on the `[optional]` token.
-          # This is for the other cases, syntax error or omitted.
-          attr_reader optional: bool
+        class Dot3Assertion < Base
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `#[TYPE, ..., TYPE]`
+        class Application < Base
+          attr_reader types: Array[Types::t]?
 
           # @rbs override
           def initialize: ...
+
+          # @rbs return: bool
+          def complete?: () -> bool
         end
 
         # `# @rbs %a{a} %a{a} ...`
@@ -113,6 +157,8 @@ module RBS
 
           # @rbs override
           def initialize: ...
+
+          def annotations: () -> Array[RBS::AST::Annotation]
         end
 
         # `# @rbs skip`
@@ -170,6 +216,8 @@ module RBS
 
           attr_reader comment: String?
 
+          include Utils
+
           # @rbs override
           def initialize: ...
         end
@@ -181,6 +229,64 @@ module RBS
           # @rbs override
           def initialize: ...
         end
+
+        # `@rbs METHOD-TYPE``
+        class Method < Base
+          type method_type = [ MethodType, method_type? ] | String
+
+          attr_reader method_types: method_type?
+
+          # `true` if the method definition is overloading something
+          attr_reader overloading: bool
+
+          attr_reader type: MethodType?
+
+          attr_reader method_type_source: String
+
+          # @rbs override
+          def initialize: ...
+
+          # : (Array[tree]) -> method_type?
+          def construct_method_types: (Array[tree]) -> method_type?
+
+          # @rbs () { (MethodType) -> void } -> void
+          #    | () -> Enumerator[MethodType, void]
+          def each_method_type: () { (MethodType) -> void } -> void
+                              | () -> Enumerator[MethodType, void]
+
+          # Returns the parsing error overload string
+          #
+          # Returns `nil` if no parsing error found.
+          def error_source: () -> String?
+        end
+
+        # `@rbs module Foo`
+        class ModuleDecl < Base
+          attr_reader name: TypeName?
+
+          attr_reader type_params: Array[RBS::AST::TypeParam]
+
+          attr_reader self_types: Array[RBS::AST::Declarations::Module::Self]
+
+          include Utils
+
+          # @rbs override
+          def initialize: ...
+        end
+
+        # `@rbs class Foo`
+        class ClassDecl < Base
+          attr_reader name: TypeName?
+
+          attr_reader type_params: Array[RBS::AST::TypeParam]
+
+          attr_reader super_class: RBS::AST::Declarations::Class::Super?
+
+          include Utils
+
+          # @rbs override
+          def initialize: ...
+        end
       end
     end
   end

data/sig/generated/rbs/inline/ast/comment_lines.rbs

@@ -3,7 +3,7 @@
 module RBS
   module Inline
     module AST
-      # CommentLines represents consecutive comments
+      # CommentLines represents consecutive comments, providing a mapping from locations in `#string` to a pair of a comment and its offset
       #
       # The comments construct one String.
       #
@@ -15,15 +15,19 @@ module RBS
       # We want to get a String of comment1 and comment2, `"Hello\nWorld".
       # And want to translate a location in the string into the location in comment1 and comment2.
       class CommentLines
-        attr_reader comments: Array[[ Prism::Comment, Integer ]]
+        attr_reader comments: Array[Prism::Comment]
 
         # @rbs comments: Array[Prism::Comment]
-        def initialize: (Array[Prism::Comment] comments) -> untyped
+        def initialize: (Array[Prism::Comment] comments) -> void
+
+        def lines: () -> Array[String]
 
         def string: () -> String
 
+        # Translates the cursor index of `#string` into the cursor index of a specific comment object
+        #
         # @rbs index: Integer
-        # @rbs returns [Prism::Comment, Integer]?
+        # @rbs return: [Prism::Comment, Integer]?
         def comment_location: (Integer index) -> [ Prism::Comment, Integer ]?
       end
     end

data/sig/generated/rbs/inline/ast/declarations.rbs

@@ -6,11 +6,14 @@ module RBS
       module Declarations
         module ConstantUtil
           # @rbs node: Prism::Node
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           def type_name: (Prism::Node node) -> TypeName?
+
+          # @rbs (Prism::Node) -> Prism::Node?
+          def value_node: (Prism::Node) -> Prism::Node?
         end
 
-        type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl
+        type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl | DataAssignDecl | StructAssignDecl
 
         interface _WithComments
           def comments: () -> AnnotationParser::ParsingResult?
@@ -18,7 +21,7 @@ module RBS
 
         # @rbs module-self _WithComments
         module Generics : _WithComments
-          # @rbs returns Array[RBS::AST::TypeParam]
+          # @rbs return: Array[RBS::AST::TypeParam]
           def type_params: () -> Array[RBS::AST::TypeParam]
         end
 
@@ -55,7 +58,7 @@ module RBS
           # @rbs node: Prism::ClassNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs super_app: Annotations::Application?
-          # @rbs returns void
+          # @rbs return: void
           def initialize: (Prism::ClassNode node, AnnotationParser::ParsingResult? comments, Annotations::Application? super_app) -> void
 
           # @rbs %a{pure}
@@ -86,25 +89,25 @@ module RBS
 
           attr_reader comments: AnnotationParser::ParsingResult?
 
-          attr_reader assertion: Annotations::Assertion?
+          attr_reader assertion: Annotations::TypeAssertion?
 
           # @rbs node: Prism::ConstantWriteNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          # @rbs assertion: Annotations::Assertion?
-          def initialize: (Prism::ConstantWriteNode node, AnnotationParser::ParsingResult? comments, Annotations::Assertion? assertion) -> untyped
+          # @rbs assertion: Annotations::TypeAssertion?
+          def initialize: (Prism::ConstantWriteNode node, AnnotationParser::ParsingResult? comments, Annotations::TypeAssertion? assertion) -> void
 
           # @rbs %a{pure}
-          # @rbs returns Types::t
+          # @rbs return: Types::t
           %a{pure}
           def type: () -> Types::t
 
           # @rbs %a{pure}
           # @rbs return Types::t?
           %a{pure}
-          def literal_type: () -> untyped
+          def literal_type: () -> Types::t?
 
           # @rbs %a{pure}
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           %a{pure}
           def constant_name: () -> TypeName?
 
@@ -113,6 +116,126 @@ module RBS
 
         class SingletonClassDecl < ModuleOrClass[Prism::SingletonClassNode]
         end
+
+        class BlockDecl < Base
+          attr_reader node: Prism::BlockNode
+
+          attr_reader comments: AnnotationParser::ParsingResult?
+
+          # Members included in the declaration
+          attr_reader members: Array[Members::t | t]
+
+          # @rbs (Prism::BlockNode, AnnotationParser::ParsingResult?) -> void
+          def initialize: (Prism::BlockNode, AnnotationParser::ParsingResult?) -> void
+
+          def start_line: () -> Integer
+
+          def module_class_annotation: () -> (Annotations::ModuleDecl | Annotations::ClassDecl | nil)
+        end
+
+        # @rbs module-self _WithTypeDecls
+        module DataStructUtil : _WithTypeDecls
+          interface _WithTypeDecls
+            def type_decls: () -> Hash[Integer, Annotations::TypeAssertion]
+
+            def each_attribute_argument: () { (Prism::Node) -> void } -> void
+
+            def comments: %a{pure} () -> AnnotationParser::ParsingResult?
+          end
+
+          # @rbs %a{pure}
+          # @rbs () { ([Symbol, Annotations::TypeAssertion?]) -> void } -> void
+          #    | () -> Enumerator[[Symbol, Annotations::TypeAssertion?], void]
+          %a{pure}
+          def each_attribute: () { ([ Symbol, Annotations::TypeAssertion? ]) -> void } -> void
+                            | () -> Enumerator[[ Symbol, Annotations::TypeAssertion? ], void]
+
+          def class_annotations: () -> Array[RBS::AST::Annotation]
+        end
+
+        class DataAssignDecl < Base
+          extend ConstantUtil
+
+          include DataStructUtil
+
+          attr_reader node: Prism::ConstantWriteNode
+
+          attr_reader comments: AnnotationParser::ParsingResult?
+
+          attr_reader type_decls: Hash[Integer, Annotations::TypeAssertion]
+
+          attr_reader data_define_node: Prism::CallNode
+
+          # @rbs (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+          def initialize: (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+
+          def start_line: () -> Integer
+
+          # @rbs %a{pure}
+          # @rbs () -> TypeName?
+          %a{pure}
+          def constant_name: () -> TypeName?
+
+          # @rbs (Prism::ConstantWriteNode) -> Prism::CallNode?
+          def self.data_define?: (Prism::ConstantWriteNode) -> Prism::CallNode?
+
+          # @rbs () { (Prism::Node) -> void } -> void
+          def each_attribute_argument: () { (Prism::Node) -> void } -> void
+        end
+
+        class StructAssignDecl < Base
+          extend ConstantUtil
+
+          include DataStructUtil
+
+          attr_reader node: Prism::ConstantWriteNode
+
+          attr_reader comments: AnnotationParser::ParsingResult?
+
+          attr_reader type_decls: Hash[Integer, Annotations::TypeAssertion]
+
+          attr_reader struct_new_node: Prism::CallNode
+
+          # @rbs (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+          def initialize: (Prism::ConstantWriteNode, Prism::CallNode, AnnotationParser::ParsingResult?, Hash[Integer, Annotations::TypeAssertion]) -> void
+
+          def start_line: () -> Integer
+
+          # @rbs %a{pure}
+          # @rbs () -> TypeName?
+          %a{pure}
+          def constant_name: () -> TypeName?
+
+          # @rbs () { (Prism::Node) -> void } -> void
+          def each_attribute_argument: () { (Prism::Node) -> void } -> void
+
+          # @rbs (Prism::ConstantWriteNode) -> Prism::CallNode?
+          def self.struct_new?: (Prism::ConstantWriteNode) -> Prism::CallNode?
+
+          # @rbs %a{pure}
+          %a{pure}
+          def keyword_init?: () -> bool
+
+          # @rbs %a{pure}
+          %a{pure}
+          def positional_init?: () -> bool
+
+          # Returns `true` is annotation is given to make all attributes *readonly*
+          #
+          # Add `# @rbs %a{rbs-inline:readonly-attributes=true}` to the class to make all attributes `attr_reader`, instead of `attr_accessor`.
+          #
+          # @rbs %a{pure}
+          %a{pure}
+          def readonly_attributes?: () -> bool
+
+          # Returns `true` if annotation is given to make all `.new` arguments required
+          #
+          # Add `# @rbs %a{rbs-inline:new-args=required}` to the class to make all of the parameters required.
+          #
+          # @rbs %a{pure}
+          %a{pure}
+          def required_new_args?: () -> bool
+        end
       end
     end
   end

data/sig/generated/rbs/inline/ast/members.rbs

@@ -37,30 +37,41 @@ module RBS
           # ```
           attr_reader visibility: RBS::AST::Members::visibility?
 
-          attr_reader assertion: Annotations::Assertion?
+          # Assertion given at the end of the method name
+          attr_reader assertion: Annotations::TypeAssertion?
 
           # @rbs node: Prism::DefNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs visibility: RBS::AST::Members::visibility?
-          # @rbs assertion: Annotations::Assertion?
-          def initialize: (Prism::DefNode node, AnnotationParser::ParsingResult? comments, RBS::AST::Members::visibility? visibility, Annotations::Assertion? assertion) -> void
+          # @rbs assertion: Annotations::TypeAssertion?
+          def initialize: (Prism::DefNode node, AnnotationParser::ParsingResult? comments, RBS::AST::Members::visibility? visibility, Annotations::TypeAssertion? assertion) -> void
 
           # Returns the name of the method
           def method_name: () -> Symbol
 
-          def method_type_annotations: () -> Array[Annotations::Assertion]
+          # Returns `nil` if no `@rbs METHOD-TYPE` or `#:` annotation is given
+          #
+          # Returns an empty array if only `...` method type is given.
+          def annotated_method_types: () -> Array[MethodType]?
 
           def return_type: () -> Types::t?
 
           def var_type_hash: () -> Hash[Symbol, Types::t?]
 
+          def splat_param_type_annotation: () -> Annotations::SplatParamType?
+
+          def double_splat_param_type_annotation: () -> Annotations::DoubleSplatParamType?
+
+          def overloading?: () -> bool
+
           def method_overloads: () -> Array[RBS::AST::Members::MethodDefinition::Overload]
 
           def method_annotations: () -> Array[RBS::AST::Annotation]
 
+          # Returns the `@rbs override` annotation
           def override_annotation: () -> AST::Annotations::Override?
 
-          def yields_annotation: () -> AST::Annotations::Yields?
+          def block_type_annotation: () -> AST::Annotations::BlockType?
         end
 
         class RubyAlias < RubyBase
@@ -70,12 +81,12 @@ module RBS
 
           # @rbs node: Prism::AliasMethodNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          def initialize: (Prism::AliasMethodNode node, AnnotationParser::ParsingResult? comments) -> untyped
+          def initialize: (Prism::AliasMethodNode node, AnnotationParser::ParsingResult? comments) -> void
 
-          # @rbs returns Symbol -- the name of *old* method
+          # @rbs return: Symbol -- the name of *old* method
           def old_name: () -> Symbol
 
-          # @rbs returns Symbol -- the name of *new* method
+          # @rbs return: Symbol -- the name of *new* method
           def new_name: () -> Symbol
         end
 
@@ -94,10 +105,10 @@ module RBS
           # @rbs node: Prism::CallNode
           # @rbs comments: AnnotationParser::ParsingResult?
           # @rbs application: Annotations::Application?
-          # @rbs returns void
+          # @rbs return: void
           def initialize: (Prism::CallNode node, AnnotationParser::ParsingResult? comments, Annotations::Application? application) -> void
 
-          # @rbs returns ::RBS::AST::Members::Include
+          # @rbs return: ::RBS::AST::Members::Include
           #            | ::RBS::AST::Members::Extend
           #            | ::RBS::AST::Members::Prepend
           #            | nil
@@ -109,16 +120,16 @@ module RBS
 
           attr_reader comments: AnnotationParser::ParsingResult?
 
-          attr_reader assertion: Annotations::Assertion?
+          attr_reader assertion: Annotations::TypeAssertion?
 
           # @rbs node: Prism::CallNode
           # @rbs comments: AnnotationParser::ParsingResult?
-          # @rbs assertion: Annotations::Assertion?
-          # @rbs returns void
-          def initialize: (Prism::CallNode node, AnnotationParser::ParsingResult? comments, Annotations::Assertion? assertion) -> void
+          # @rbs assertion: Annotations::TypeAssertion?
+          # @rbs return: void
+          def initialize: (Prism::CallNode node, AnnotationParser::ParsingResult? comments, Annotations::TypeAssertion? assertion) -> void
 
           # @rbs return Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
-          def rbs: () -> untyped
+          def rbs: () -> Array[RBS::AST::Members::AttrReader | RBS::AST::Members::AttrWriter | RBS::AST::Members::AttrAccessor]?
 
           # Returns the type of the attribute
           #