rbs 4.1.0.pre.2-java

data/sig/namespace.rbs

@@ -0,0 +1,161 @@
+module RBS
+  # Namespace instance represents a _prefix of module names_.
+  #
+  # ```
+  # vvvvvvvvvvvvvv  TypeName
+  # RBS::Namespace
+  # ^^^^^           Namespace
+  #
+  # vvvvvvvvvv    TypeName
+  # RBS::Types
+  # ^^^^^         Namespace
+  #
+  # vvvvvvvvvvvvvvvvv    TypeName
+  # RBS::Types::Union
+  # ^^^^^^^^^^^^         Namespace
+  # ```
+  #
+  # Note that `Namespace` is an RBS specific concept and there is no corresponding concept in Ruby.
+  #
+  # There are _absolute_ and _relative_ namespaces.
+  #
+  # ```
+  # Namespace(::RBS::)         # Absolute namespace
+  # Namespace(  RBS::)         # Relative namespace
+  # ```
+  #
+  # It also defines two special namespaces.
+  #
+  # ```
+  # ::              # _Root_ namespace
+  #                 # _Empty_ namespace
+  # ```
+  #
+  class Namespace
+    attr_reader path: Array[Symbol]
+
+    def initialize: (path: Array[Symbol], absolute: boolish) -> void
+
+    @absolute: bool
+
+    @parent: Namespace?
+
+    @hash: Integer?
+
+    self.@root: Namespace?
+
+    self.@empty: Namespace?
+
+    self.@intern_mutex: Mutex
+
+    # Per-`absolute` flag tries of nested Hashes keyed on path Symbols,
+    # with the cached Namespace stored under the `INTERN_LEAF` sentinel
+    # at each path's terminal node.
+    self.@intern_trie_absolute: Hash[Symbol | Module, untyped]
+
+    self.@intern_trie_relative: Hash[Symbol | Module, untyped]
+
+    INTERN_LEAF: Module
+
+    # Returns an interned `Namespace` instance.
+    #
+    # Subsequent calls with structurally equal `path` and `absolute` arguments
+    # return the same object. The internal `path` array is duplicated and
+    # frozen before being cached.
+    def self.[]: (Array[Symbol] path, boolish absolute) -> Namespace
+
+    # Returns new _empty_ namespace.
+    def self.empty: () -> Namespace
+
+    # Returns new _root_ namespace.
+    def self.root: () -> Namespace
+
+    # Concat two namespaces.
+    #
+    # ```rb
+    # Namespace("Foo::") + Namespace("Bar::")   # => Foo::Bar::
+    # Namespace("::Foo::") + Namespace("Bar::") # => ::Foo::Bar::
+    # ```
+    #
+    # If `other` is an absolute namespace, it returns `other`.
+    #
+    # ```rb
+    # Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
+    # ```
+    def +: (Namespace other) -> Namespace
+
+    # Add one path component to self.
+    #
+    # ```rb
+    # Namespace("Foo::").append(:Bar) # => Namespace("Foo::Bar::")
+    # ```
+    def append: (Symbol component) -> Namespace
+
+    # Returns parent namespace.
+    # Raises error there is no parent namespace.
+    #
+    # ```rb
+    # Namespace("::A").parent    # => Namespace("::")
+    # Namespace("::").parent     # raises error
+    # Namespace("A::B").parent   # => Namespace("A")
+    # ```
+    def parent: () -> Namespace
+
+    # Returns true if self is absolute namespace.
+    def absolute?: () -> bool
+
+    # Returns true if self is relative namespace.
+    def relative?: () -> bool
+
+    # Returns absolute namespace.
+    #
+    # ```rb
+    # Namespace("A").absolute!      # => Namespace("::A")
+    # Namespace("::A").absolute!    # => Namespace("::A")
+    # ```
+    def absolute!: () -> Namespace
+
+    # Returns _relative_ namespace.
+    #
+    def relative!: () -> Namespace
+
+    def empty?: () -> bool
+
+    # Equality is defined by its structure.
+    #
+    def ==: (untyped other) -> bool
+
+    alias eql? ==
+
+    # Hash is defined based on its structure.
+    #
+    def hash: () -> Integer
+
+    # Returns a pair of parent namespace and a symbol of last component.
+    #
+    # ```rb
+    # Namespace("::A::B::C").split    # => [Namespace("::A::B::"), :C]
+    # ```
+    def split: () -> [Namespace, Symbol]?
+
+    def to_s: () -> String
+
+    # Construct a type name which points to the same name type.
+    #
+    def to_type_name: () -> TypeName
+
+    def self.parse: (String string) -> Namespace
+
+    # Iterate over Namespace for each element in ascending order.
+    #
+    # ```rb
+    # Namespace.parse("::A::B::C").ascend {|ns| p ns }
+    #   # => ::A::B::C
+    #   # => ::A::B
+    #   # => ::A
+    #   # => ::(root)
+    # ```
+    def ascend: () { (Namespace) -> void } -> void
+              | () -> Enumerator[Namespace, void]
+  end
+end

data/sig/parser.rbs

@@ -0,0 +1,164 @@
+module RBS
+  class Parser
+    # Result of `Parser.lex`
+    class LexResult
+      attr_reader buffer: Buffer
+      attr_reader value: Array[Token]
+
+      def initialize: (buffer: Buffer, value: Array[Token]) -> void
+    end
+
+    # Represents a token per result of `Parser.lex`.
+    class Token
+      attr_reader type: Symbol
+      attr_reader location: Location[untyped, untyped]
+
+      def initialize: (type: Symbol, location: Location[untyped, untyped]) -> void
+      def value: () -> String
+      def comment?: () -> bool
+    end
+
+    # Parse a method type and return it
+    #
+    # When `byte_range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
+    #
+    # ```ruby
+    # RBS::Parser.parse_method_type("() -> void")                                     # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void", byte_range: 0...)                   # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", byte_range: 11...)     # => `() -> String`
+    # RBS::Parser.parse_method_type("() -> void () -> String", byte_range: 23...)     # => nil
+    # ```
+    #
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: false)    # => `() -> void`
+    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_method_type("", require_eof: true)                            # => nil
+    # ```
+    #
+    def self.parse_method_type: (Buffer | String, ?byte_range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
+                              | %a{deprecated: Use `byte_range:` keyword instead of `range:`} (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
+
+    # Parse a type and return it
+    #
+    # When `byte_range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("String")                               # => `String`
+    # RBS::Parser.parse_type("String", byte_range: 0...)             # => `String`
+    # RBS::Parser.parse_type("String Integer", byte_range: 7...)     # => `Integer`
+    # RBS::Parser.parse_type("String Integer", byte_range: 14...)    # => nil
+    # ```
+    #
+    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
+    # (Defaults to `false`.)
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("String untyped", require_eof: false)    # => `String`
+    # RBS::Parser.parse_type("String untyped", require_eof: true)     # => Raises an error
+    #
+    # RBS::Parser.parse_type("", require_eof: true)                   # => nil
+    # ```
+    #
+    # The `void_allowed` keyword controls whether `void` is allowed as a type.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("void", void_allowed: true)          # => `void`
+    # RBS::Parser.parse_type("void", void_allowed: false)         # => Raises an syntax error
+    # ```
+    #
+    # The `self_allowed` keyword controls whether `self` is allowed as a type.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type("self", self_allowed: true)          # => `self`
+    # RBS::Parser.parse_type("self", self_allowed: false)         # => Raises an syntax error
+    # ```
+    #
+    def self.parse_type: (Buffer | String, ?byte_range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool, ?void_allowed: bool, ?self_allowed: bool, ?classish_allowed: bool) -> Types::t?
+                       | %a{deprecated: Use `byte_range:` keyword instead of `range:`} (Buffer | String, range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool, ?void_allowed: bool, ?self_allowed: bool, ?classish_allowed: bool) -> Types::t?
+
+    # Parse whole RBS file and return an array of declarations
+    #
+    def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
+
+    # Parse a list of type parameters and return it
+    #
+    # ```ruby
+    # RBS::Parser.parse_type_params("")                          # => nil
+    # RBS::Parser.parse_type_params("[U, V]")                    # => `[:U, :V]`
+    # RBS::Parser.parse_type_params("[in U, V < Integer]")       # => `[:U, :V]`
+    # ```
+    #
+    # When `module_type_params` is `false`, an error is raised if `unchecked`, `in` or `out` are used.
+    #
+    # ```ruby
+    # RBS::Parser.parse_type_params("[unchecked U]", module_type_params: false)   # => Raises an error
+    # RBS::Parser.parse_type_params("[out U]", module_type_params: false)         # => Raises an error
+    # RBS::Parser.parse_type_params("[in U]", module_type_params: false)          # => Raises an error
+    # ```
+    #
+    def self.parse_type_params: (Buffer | String, ?module_type_params: bool) -> Array[AST::TypeParam]
+
+    # Returns the magic comment from the buffer
+    #
+    def self.magic_comment: (Buffer) -> AST::Directives::ResolveTypeNames?
+
+    # Parse whole RBS file and return result.
+    #
+    # ```ruby
+    # RBS::Parser.lex("# Comment\nmodule A\nend\n").value.map(&:type)
+    # # => [:tLINECOMMENT, :kMODULE, :tUIDENT, :kEND, :pEOF]
+    # ```
+    def self.lex: (Buffer | String) -> LexResult
+
+    KEYWORDS: Hash[String, bot]
+
+    # Parse a leading annotation and return it
+    #
+    # Raises an exception if the source text contains a syntax error.
+    #
+    def self.parse_inline_leading_annotation: (Buffer | String, Range[Integer?], ?variables: Array[Symbol]) -> AST::Ruby::Annotations::leading_annotation
+
+    # Parse a leading annotation and return it
+    #
+    # Raises an exception if the source text contains a syntax error.
+    #
+    def self.parse_inline_trailing_annotation: (Buffer | String, Range[Integer?], ?variables: Array[Symbol]) -> AST::Ruby::Annotations::trailing_annotation
+
+    private
+
+    def self.buffer: (String | Buffer source) -> Buffer
+
+    def self.byte_range: (Range[Integer?] char_range, String content) -> Range[Integer?]
+
+    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> Types::t?
+
+    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
+
+    def self._parse_signature: (Buffer, Integer start_pos, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+
+    # Parse and serialize the result to the binary format consumed by
+    # RBS::WASM::Deserializer (see ext/rbs_extension/main.c and
+    # docs/wasm_serialization.md). The `_to_bytes` variants exist so the
+    # round-trip can be exercised on CRuby.
+    def self._parse_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof, bool void_allowed, bool self_allowed, bool classish_allowed) -> String?
+
+    def self._parse_method_type_to_bytes: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> String?
+
+    def self._parse_signature_to_bytes: (Buffer, Integer start_pos, Integer end_pos) -> String
+
+    def self._parse_type_params: (Buffer, Integer start_pos, Integer end_pos, bool module_type_params) -> Array[AST::TypeParam]
+
+    def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
+
+    def self._parse_inline_leading_annotation: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> AST::Ruby::Annotations::leading_annotation
+
+    def self._parse_inline_trailing_annotation: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables) -> AST::Ruby::Annotations::trailing_annotation
+
+    class LocatedValue
+    end
+  end
+end

data/sig/prototype/helpers.rbs

@@ -0,0 +1,29 @@
+module RBS
+  module Prototype
+    module Helpers
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      def parse_comments: (String, include_trailing: bool) -> Hash[Integer, AST::Comment]
+
+      def block_from_body: (node) -> Types::Block?
+
+      def each_node: (Array[untyped] nodes) { (node) -> void } -> void
+
+      def each_child: (node) { (node child) -> void } -> void
+
+      def any_node?: (node, ?nodes: Array[node]) { (node) -> bool } -> Array[node]?
+
+      def keyword_hash?: (node) -> bool
+
+      # Returns a symbol if the node is a symbol literal node
+      # 
+      def symbol_literal_node?: (node) -> Symbol?
+
+      def args_from_node: (node?) -> Array[untyped]
+
+      def untyped: () -> Types::Bases::Any
+
+      @untyped: Types::Bases::Any
+    end
+  end
+end

data/sig/prototype/node_usage.rbs

@@ -0,0 +1,20 @@
+module RBS
+  module Prototype
+    class NodeUsage
+      include Helpers
+      
+      type node = RubyVM::AbstractSyntaxTree::Node
+
+      attr_reader node: node
+
+      attr_reader conditional_nodes: Set[node]
+
+      def initialize: (node) -> void
+
+      def calculate: (node, conditional: bool) -> void
+
+      def each_conditional_node: () { (node) -> void } -> void
+                               | () -> Enumerator[node, void]
+    end
+  end
+end

data/sig/prototype/rb.rbs

@@ -0,0 +1,96 @@
+module RBS
+  module Prototype
+    class RB
+      include Helpers
+
+      class Context
+        type method_kind = :singleton | :singleton_instance | :instance
+
+        attr_accessor module_function: bool
+
+        attr_accessor singleton: bool
+
+        attr_accessor namespace: Namespace
+
+        attr_accessor in_def: bool
+
+        def initialize: (module_function: bool, singleton: bool, namespace: Namespace, in_def: bool) -> void
+
+        def method_kind: () -> method_kind
+
+        def attribute_kind: () -> (:singleton | :instance)
+
+        def enter_namespace: (Namespace) -> Context
+
+        def update: (?module_function: bool, ?singleton: bool, ?in_def: bool) -> Context
+
+        def self.initial: (?namespace: Namespace) -> Context
+      end
+
+      type decl = AST::Declarations::t | AST::Members::t
+
+      attr_reader source_decls: Array[decl]
+
+      def initialize: () -> void
+
+      def decls: () -> Array[AST::Declarations::t]
+
+      def parse: (String) -> void
+
+      def process: (untyped node, decls: Array[AST::Declarations::t | AST::Members::t], comments: Hash[Integer, AST::Comment], context: Context) -> void
+
+      def process_children: (RubyVM::AbstractSyntaxTree::Node node, decls: Array[decl], comments: Hash[Integer, AST::Comment], context: Context) -> void
+
+      # Returns a type name that represents the name of the constant.
+      # `node` must be _constant_ node, `CONST`, `COLON2`, or `COLON3` node.
+      #
+      def const_to_name!: (RubyVM::AbstractSyntaxTree::Node node, ?context: Context?) -> TypeName
+
+      # Returns a type name that represents the name of the constant.
+      # `node` can be `SELF` for `extend self` pattern.
+      #
+      def const_to_name: (RubyVM::AbstractSyntaxTree::Node? node, context: Context) -> TypeName?
+
+      def literal_to_symbol: (RubyVM::AbstractSyntaxTree::Node node) -> Symbol?
+
+      def function_type_from_body: (RubyVM::AbstractSyntaxTree::Node node, Symbol def_name) -> Types::Function
+
+      def function_return_type_from_body: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def body_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def if_unless_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def block_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def literal_to_type: (RubyVM::AbstractSyntaxTree::Node node) -> Types::t
+
+      def types_to_union_type: (Array[Types::t] types) -> Types::t
+
+      def range_element_type: (Array[Types::t] types) -> Types::t
+
+      def param_type: (RubyVM::AbstractSyntaxTree::Node node, ?default: Types::Bases::Any) -> Types::t
+
+      # backward compatible
+      alias node_type param_type
+
+      def private: () -> AST::Members::Private
+
+      @private: AST::Members::Private?
+
+      def public: () -> AST::Members::Public
+
+      @public: AST::Members::Public?
+
+      def current_accessibility: (Array[decl] decls, ?Integer index) -> (AST::Members::Private | AST::Members::Public)
+
+      def remove_unnecessary_accessibility_methods!: (Array[decl]) -> void
+
+      def is_accessibility?: (decl) -> bool
+
+      def find_def_index_by_name: (Array[decl] decls, Symbol name) -> [Integer, AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrWriter]?
+
+      def sort_members!: (Array[decl] decls) -> void
+    end
+  end
+end

data/sig/prototype/rbi.rbs

@@ -0,0 +1,75 @@
+module RBS
+  module Prototype
+    class RBI
+      include Helpers
+      
+      attr_reader decls: Array[AST::Declarations::t]
+
+      type module_decl = AST::Declarations::Class | AST::Declarations::Module
+
+      # A stack representing the module nesting structure in the Ruby code
+      attr_reader modules: Array[module_decl]
+
+      # Last subsequent `sig` calls
+      attr_reader last_sig: Array[RubyVM::AbstractSyntaxTree::Node]?
+
+      def initialize: () -> void
+
+      def parse: (String) -> void
+
+      def nested_name: (RubyVM::AbstractSyntaxTree::Node name) -> TypeName
+
+      def current_namespace: () -> Namespace
+
+      def push_class: (
+        RubyVM::AbstractSyntaxTree::Node name,
+        RubyVM::AbstractSyntaxTree::Node super_class,
+        comment: AST::Comment?
+      ) { () -> void } -> void
+
+      def push_module: (RubyVM::AbstractSyntaxTree::Node name, comment: AST::Comment?) { () -> void } -> void
+
+      # The inner most module/class definition, returns `nil` on toplevel
+      def current_module: () -> module_decl?
+
+      # The inner most module/class definition, raises on toplevel
+      def current_module!: () -> module_decl
+
+      # Put a `sig` call to current list.
+      def push_sig: (RubyVM::AbstractSyntaxTree::Node node) -> void
+
+      # Clear the `sig` call list
+      def pop_sig: () -> Array[RubyVM::AbstractSyntaxTree::Node]?
+
+      def join_comments: (Array[RubyVM::AbstractSyntaxTree::Node] nodes, Hash[Integer, AST::Comment] comments) -> AST::Comment
+
+      def process: (RubyVM::AbstractSyntaxTree::Node node, comments: Hash[Integer, AST::Comment], ?outer: Array[RubyVM::AbstractSyntaxTree::Node]) -> void
+
+      def method_type: (RubyVM::AbstractSyntaxTree::Node? args_node, RubyVM::AbstractSyntaxTree::Node? type_node, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType?
+
+      def parse_params: (RubyVM::AbstractSyntaxTree::Node args_node, RubyVM::AbstractSyntaxTree::Node args, MethodType method_type, variables: Array[AST::TypeParam], overloads: Integer) -> MethodType
+
+      def type_of: (RubyVM::AbstractSyntaxTree::Node type_node, variables: Array[AST::TypeParam]) -> Types::t
+
+      def type_of0: (RubyVM::AbstractSyntaxTree::Node type_node, variables: Array[AST::TypeParam]) -> Types::t
+
+      def proc_type?: (RubyVM::AbstractSyntaxTree::Node type_node) -> bool
+
+      def call_node?: (RubyVM::AbstractSyntaxTree::Node node, name: Symbol, ?receiver: ^(RubyVM::AbstractSyntaxTree::Node) -> bool, ?args: ^(RubyVM::AbstractSyntaxTree::Node) -> bool) -> bool
+
+      # Receives a constant node and returns `TypeName` instance
+      def const_to_name: (RubyVM::AbstractSyntaxTree::Node node) -> TypeName
+
+      # Receives `:ARRAY` or `:LIST` node and yields the child nodes.
+      def each_arg: (RubyVM::AbstractSyntaxTree::Node array) { (RubyVM::AbstractSyntaxTree::Node) -> void } -> void
+                  | (RubyVM::AbstractSyntaxTree::Node array) -> Enumerator[RubyVM::AbstractSyntaxTree::Node, void]
+
+      # Receives node and yields the child nodes.
+      def each_child: (RubyVM::AbstractSyntaxTree::Node node) { (RubyVM::AbstractSyntaxTree::Node) -> void } -> void
+                    | (RubyVM::AbstractSyntaxTree::Node node) -> Enumerator[RubyVM::AbstractSyntaxTree::Node, void]
+
+      # Receives a keyword `:HASH` node and returns hash instance.
+      def node_to_hash: (RubyVM::AbstractSyntaxTree::Node node) -> Hash[Symbol, RubyVM::AbstractSyntaxTree::Node]?
+    end
+  end
+end