rbs-inline 0.3.0 → 0.5.0

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

@@ -4,6 +4,25 @@ module RBS
   module Inline
     module AST
       module Annotations
+        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
 
@@ -11,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
 
@@ -25,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?
 
@@ -38,7 +92,7 @@ module RBS
           # @rbs override
           def initialize: ...
 
-          # @rbs returns bool
+          # @rbs return: bool
           def complete?: () -> bool
         end
 
@@ -56,53 +110,45 @@ module RBS
           def initialize: ...
         end
 
-        # `#:: TYPE`
-        class Assertion < Base
-          attr_reader type: Types::t | MethodType | nil
+        class MethodTypeAssertion < Base
+          attr_reader method_type: MethodType
 
-          def initialize: (untyped tree, untyped source) -> untyped
-
-          # @rbs returns bool
-          def complete?: () -> bool
-
-          # 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} ...`
@@ -168,6 +214,8 @@ module RBS
 
           attr_reader comment: String?
 
+          include Utils
+
           # @rbs override
           def initialize: ...
         end
@@ -179,6 +227,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

@@ -0,0 +1,35 @@
+# Generated from lib/rbs/inline/ast/comment_lines.rb with RBS::Inline
+
+module RBS
+  module Inline
+    module AST
+      # 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.
+      #
+      # ```ruby
+      # # Hello       <-- Comment1
+      # # World       <-- Comment2
+      # ```
+      #
+      # 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]
+
+        # @rbs comments: Array[Prism::Comment]
+        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 return: [Prism::Comment, Integer]?
+        def comment_location: (Integer index) -> [ Prism::Comment, Integer ]?
+      end
+    end
+  end
+end

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

@@ -6,11 +6,11 @@ module RBS
       module Declarations
         module ConstantUtil
           # @rbs node: Prism::Node
-          # @rbs returns TypeName?
+          # @rbs return: TypeName?
           def type_name: (Prism::Node node) -> TypeName?
         end
 
-        type t = ClassDecl | ModuleDecl | ConstantDecl
+        type t = ClassDecl | ModuleDecl | ConstantDecl | SingletonClassDecl | BlockDecl
 
         interface _WithComments
           def comments: () -> AnnotationParser::ParsingResult?
@@ -18,7 +18,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 +55,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,30 +86,49 @@ 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?
 
           def start_line: () -> Integer
         end
+
+        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
       end
     end
   end

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

@@ -4,6 +4,12 @@ module RBS
   module Inline
     module AST
       module Members
+        type ruby = RubyDef | RubyAlias | RubyMixin | RubyAttr | RubyPublic | RubyPrivate
+
+        type rbs = RBSIvar | RBSEmbedded
+
+        type t = ruby | rbs
+
         class Base
           attr_reader location: Prism::Location
 
@@ -31,40 +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 the `kind` of the method definition
-          #
-          # [FIXME] It only supports `self` receiver.
+          # Returns `nil` if no `@rbs METHOD-TYPE` or `#:` annotation is given
           #
-          # ```rb
-          # def self.foo = ()    # :singleton
-          # def object.foo = ()  # Not supported (returns :instance)
-          # ```
-          def method_kind: () -> RBS::AST::Members::MethodDefinition::kind
+          # 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
@@ -74,16 +81,18 @@ 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
 
         class RubyMixin < RubyBase
+          include Declarations::ConstantUtil
+
           # CallNode that calls `include`, `prepend`, and `extend` method
           attr_reader node: Prism::CallNode
 
@@ -96,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
@@ -111,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
           #

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

@@ -0,0 +1,132 @@
+# Generated from lib/rbs/inline/ast/tree.rb with RBS::Inline
+
+module RBS
+  module Inline
+    module AST
+      type token = [ Symbol, String ]
+
+      type tree = token | Tree | Types::t | MethodType | nil
+
+      class Tree
+        attr_reader trees: Array[tree]
+
+        attr_reader type: Symbol
+
+        # Children but without `tWHITESPACE` tokens
+        attr_reader non_trivia_trees: Array[tree]
+
+        # @rbs type: Symbol
+        def initialize: (Symbol type) -> void
+
+        # @rbs tok: tree
+        # @rbs return: self
+        def <<: (tree tok) -> self
+
+        # Returns the source code associated to the tree
+        def to_s: () -> String
+
+        # Returns `true` if token at the given index is of the given type
+        def token?: (untyped type, at: untyped) -> untyped
+
+        # Returns `true` if tree at the given index is of the given type
+        def tree?: (untyped type, at: untyped) -> untyped
+
+        # Returns n-th token from the children
+        #
+        # Raises if the value is not a token or nil.
+        #
+        # @rbs index: Integer
+        # @rbs return: token?
+        def nth_token: (Integer index) -> token?
+
+        # Returns n-th token from the children
+        #
+        # Returns `nil` if the value is not a token.
+        #
+        # @rbs index: Integer
+        # @rbs return: token?
+        def nth_token?: (Integer index) -> token?
+
+        # Returns n-th token from the children
+        #
+        # Raises if the value is not token.
+        #
+        # @rbs index: Integer
+        # @rbs return: token
+        def nth_token!: (Integer index) -> token
+
+        # Returns n-th tree from the children
+        #
+        # Raises if the value is not a tree or nil.
+        #
+        # @rbs index: Integer
+        # @rbs return: Tree?
+        def nth_tree: (Integer index) -> Tree?
+
+        # Returns n-th tree from the children
+        #
+        # Returns `nil` if the value is not a tree or nil.
+        #
+        # @rbs index: Integer
+        # @rbs return: Tree?
+        def nth_tree?: (Integer index) -> Tree?
+
+        # Returns n-th tree from the children
+        #
+        # Raises if the value is not a tree.
+        #
+        # @rbs index: Integer
+        # @rbs return: Tree
+        def nth_tree!: (Integer index) -> Tree
+
+        # Returns n-th type from the children
+        #
+        # Raises if the value is not a type or nil.
+        #
+        # @rbs index: Integer
+        # @rbs return: Types::t?
+        def nth_type: (Integer index) -> Types::t?
+
+        # Returns n-th type from the children
+        #
+        # Returns `nil` if the value is not a type.
+        #
+        # @rbs index: Integer
+        # @rbs return: Types::t?
+        def nth_type?: (Integer index) -> Types::t?
+
+        # Returns n-th type from the children
+        #
+        # Raises if the value is not a type.
+        #
+        # @rbs index: Integer
+        # @rbs return: Types::t
+        def nth_type!: (Integer index) -> Types::t
+
+        # Returns n-th method type from the children
+        #
+        # Raises if the value is not a method type or `nil`.
+        #
+        # @rbs index: Integer
+        # @rbs return: MethodType?
+        def nth_method_type: (Integer index) -> MethodType?
+
+        # Returns n-th method type from the children
+        #
+        # Returns `nil` if the value is not a method type.
+        #
+        # @rbs index: Integer
+        # @rbs return: MethodType?
+        def nth_method_type?: (Integer index) -> MethodType?
+
+        # Returns n-th method tree from the children
+        #
+        # Raises if the value is not a method tree.
+        #
+        # @rbs index: Integer
+        # @rbs return: MethodType
+        def nth_method_type!: (Integer index) -> MethodType
+      end
+    end
+  end
+end

data/sig/generated/rbs/inline/cli.rbs

@@ -25,12 +25,12 @@ module RBS
         # @rbs output_path: Pathname
         def initialize: (Pathname pwd, Array[Pathname] base_paths, Pathname output_path) -> void
 
-        # :: (Pathname) -> Pathname?
+        # : (Pathname) -> Pathname?
         def calculate: (Pathname) -> Pathname?
 
         # @rbs path: Pathname
         # @rbs prefix: Pathname
-        # @rbs returns bool
+        # @rbs return: bool
         def has_prefix?: (Pathname path, prefix: Pathname) -> bool
       end
 
@@ -45,7 +45,7 @@ module RBS
       def initialize: (?stdout: IO, ?stderr: IO) -> void
 
       # @rbs args: Array[String]
-      # @rbs returns Integer
+      # @rbs return: Integer
       def run: (Array[String] args) -> Integer
     end
   end

data/sig/generated/rbs/inline/node_utils.rbs

@@ -0,0 +1,11 @@
+# Generated from lib/rbs/inline/node_utils.rb with RBS::Inline
+
+module RBS
+  module Inline
+    module NodeUtils
+      # @rbs node: Prism::Node
+      # @rbs return: TypeName?
+      def type_name: (Prism::Node node) -> TypeName?
+    end
+  end
+end