rbs 4.1.0.pre.2-java

data/sig/prototype/runtime.rbs

@@ -0,0 +1,182 @@
+module RBS
+  module Prototype
+    class Runtime
+      module Reflection
+        self.@object_class: UnboundMethod
+        def self.object_class: (Module value) -> Class
+
+        self.@constants_of: UnboundMethod
+        def self.constants_of: (Module mod, ?bool inherit) -> Array[Symbol]
+      end
+
+      module Helpers
+        @module_name_method: UnboundMethod
+        @untyped: Types::Bases::Any
+
+        private
+
+        def const_name: (Module const) -> String?
+
+        def const_name!: (Module const) -> String
+
+        # Returns the exact name & not compactly declared name
+        def only_name: (Module mod) -> String
+
+        def to_type_name: (String name, ?full_name: bool) -> TypeName
+
+        def untyped: () -> Types::Bases::Any
+      end
+
+      class ValueObjectBase
+        include Helpers
+
+        # @target_class stores the singleton object of `Data` or `Struct` subclass
+        @target_class: untyped
+
+        def build_decl: () -> AST::Declarations::Class
+
+        private
+
+        def build_member_accessors: (untyped ast_members_class) -> untyped
+
+        def build_s_members: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+
+        def add_decl_members: (AST::Declarations::Class) -> void
+
+        def initialize: (Class target_class) -> void
+      end
+
+      class StructGenerator < ValueObjectBase
+        def self.generatable?: (Class target) -> bool
+
+        private
+
+        def add_decl_members: (AST::Declarations::Class decl) -> void
+
+        def build_overload_for_keyword_arguments: () -> AST::Members::MethodDefinition::Overload
+
+        def build_overload_for_positional_arguments: () -> AST::Members::MethodDefinition::Overload
+
+        def build_s_keyword_init_p: () -> Array[AST::Members::MethodDefinition]
+
+        def build_s_new: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+
+        CAN_CALL_KEYWORD_INIT_P: bool
+      end
+
+      class DataGenerator < ValueObjectBase
+        def self.generatable?: (Class target) -> bool
+
+        private
+
+        def add_decl_members: (AST::Declarations::Class decl) -> void
+
+        def build_s_new: () -> Array[AST::Members::MethodDefinition]
+
+        def build_super_class: () -> AST::Declarations::Class::Super
+      end
+
+      class Todo
+        @builder: DefinitionBuilder
+
+        @mixin_decls_cache: Hash[TypeName, Array[untyped]]
+
+        def initialize: (builder: DefinitionBuilder) -> void
+
+        def skip_mixin?: (type_name: TypeName, module_name: TypeName, mixin_class: mixin_class) -> bool
+
+        def skip_singleton_method?: (module_name: TypeName, method: UnboundMethod, accessibility: Definition::accessibility) -> bool
+
+        def skip_instance_method?: (module_name: TypeName, method: UnboundMethod, accessibility: Definition::accessibility) -> bool
+
+        def skip_constant?: (module_name: String, name: Symbol) -> bool
+
+        private def mixin_decls: (TypeName type_name) -> Array[AST::Members::Include | AST::Members::Extend | AST::Members::Prepend]
+      end
+
+      type mixin_class = singleton(AST::Members::Include) | singleton(AST::Members::Prepend) | singleton(AST::Members::Extend)
+
+      @decls: Array[AST::Declarations::t]?
+
+      @modules: Hash[String, Module]
+
+      @builder: DefinitionBuilder
+
+      @module_name_method: UnboundMethod
+      @object_class: UnboundMethod
+
+      @todo_object: Todo?
+
+      include Helpers
+
+      attr_reader patterns: Array[String]
+
+      attr_reader env: Environment
+
+      attr_reader merge: bool
+
+      attr_reader todo: bool
+
+      attr_accessor outline: bool
+
+      attr_reader owners_included: Array[Module]
+
+      def initialize: (patterns: Array[String], env: Environment, merge: bool, ?todo: bool, ?owners_included: Array[Symbol]) -> void
+
+      def target?: (Module const) -> bool
+
+      def todo_object: () -> Todo?
+
+      def builder: () -> DefinitionBuilder
+
+      def parse: (String file) -> void
+
+      def decls: () -> Array[AST::Declarations::t]
+
+      def each_mixined_module: (TypeName type_name, Module mod) { (TypeName, TypeName, mixin_class) -> void } -> void
+
+      def each_mixined_module_one: (TypeName type_name, Module mod) { (TypeName, TypeName, bool) -> void } -> void
+
+      def method_type: (UnboundMethod method) -> MethodType
+
+      def merge_rbs: [A] (TypeName module_name, Array[AST::Declarations::Class::member] members, singleton: Symbol) { () -> A } -> A?
+                   | [A] (TypeName module_name, Array[AST::Declarations::Class::member] members, instance: Symbol) { () -> A } -> A?
+
+      def target_method?: (Module mod, instance: Symbol) -> bool
+                        | (Module mod, singleton: Symbol) -> bool
+
+      def generate_methods: (Module mod, TypeName module_name, Array[AST::Declarations::Class::member] members) -> void
+
+      def generate_constants: (Module mod, Array[AST::Declarations::Class::member] decls) -> void
+
+      def generate_super_class: (Class mod) -> AST::Declarations::Class::Super?
+
+      def generate_class: (Class mod) -> void
+
+      def generate_module: (Module mod) -> void
+
+      def generate_mixin: (Module mod, AST::Declarations::Class | AST::Declarations::Module, TypeName, TypeName) -> void
+
+      # Generate/find outer module declarations
+      # This is broken down into another method to comply with `DRY`
+      # This generates/finds declarations in nested form & returns the last array of declarations
+      def ensure_outer_module_declarations: (Module mod) -> Array[AST::Declarations::Class::member]
+
+      def object_class: (untyped) -> untyped
+
+      def type_args: (TypeName type_name) -> Array[Types::t]
+
+      def block_from_ast_of: (UnboundMethod method) -> Types::Block?
+
+      def block_from_body: (RubyVM::AbstractSyntaxTree::Node) -> Types::Block?
+
+      def can_alias?: (Module, UnboundMethod) -> bool
+
+      def type_params: (Module) -> Array[AST::TypeParam]
+    end
+  end
+end

data/sig/rbs.rbs

@@ -0,0 +1,21 @@
+module RBS
+  def self.logger: () -> Logger
+
+  def self.logger_level: () -> Integer?
+
+  def self.logger_level=: (Integer?) -> Integer?
+
+  %a{pure} def self.logger_output: () -> IO?
+
+  def self.logger_output=: (IO) -> IO
+
+  def self.print_warning: () { () -> String } -> void
+
+  self.@logger: Logger?
+
+  self.@logger_output: IO?
+
+  self.@logger_level: Integer?
+
+  self.@warnings: Set[String]
+end

data/sig/rdoc/rbs.rbs

@@ -0,0 +1,67 @@
+module RDoc
+  class Parser
+    class RBS < Parser
+    end
+  end
+end
+
+module RBS
+  module RDocPlugin
+    class Parser
+      @top_level: RDoc::TopLevel
+
+      @content: String
+
+      type allowed_decls = RBS::AST::Declarations::Class
+                         | RBS::AST::Declarations::Module
+                         | RBS::AST::Declarations::Constant
+
+      def initialize: (RDoc::TopLevel top_level, String content) -> void
+
+      def scan: () -> RDoc::TopLevel
+
+      def parse_member: (decl: RBS::AST::Declarations::t | RBS::AST::Members::t, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_class_decl: (decl: RBS::AST::Declarations::Class, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_module_decl: (decl: RBS::AST::Declarations::Module | RBS::AST::Declarations::Interface, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_constant_decl: (decl: RBS::AST::Declarations::Constant, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_method_decl: (decl: RBS::AST::Members::MethodDefinition, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_method_alias_decl: (decl: RBS::AST::Members::Alias, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_attr_decl: (decl: RBS::AST::Members::AttrReader | RBS::AST::Members::AttrAccessor | RBS::AST::Members::AttrWriter, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_include_decl: (decl: RBS::AST::Members::Include, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      def parse_extend_decl: (decl: RBS::AST::Members::Extend, context: RDoc::Context, ?outer_name: RBS::TypeName?) -> void
+
+      private
+
+      def construct_comment: (context: RDoc::Context, comment: String) -> RDoc::Comment
+
+      # _DeclWithComment is a utility interface that has `#comment`
+      #
+      interface _DeclWithComment
+        def comment: () -> ::RBS::AST::Comment?
+      end
+
+      # Extract comment string from a declaration with comment
+      #
+      # * If `#comment" returns a Comment object, it returns its `#string` value
+      # * If `#comment` returns `nil`, it raises an error
+      #
+      # Note that you have to confirm if the `#comment` of given declaration exists.
+      #
+      # ```ruby
+      # comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+      # ```
+      #
+      def comment_string: (_DeclWithComment) -> String
+
+      def fully_qualified_name: (outer_name: RBS::TypeName?, decl: allowed_decls) -> RBS::TypeName
+    end
+  end
+end

data/sig/repository.rbs

@@ -0,0 +1,85 @@
+module RBS
+  # Set of RBS repositories.
+  #
+  # A repository object can handle multiple repository roots.
+  #
+  # ```ruby
+  # repo = RBS::Repository.new()
+  # repo.add(Pathname("vendor/rbs/gem-rbs"))
+  # repo.add(Pathname("vendor/rbs/internal-rbs"))
+  # repo.add(Pathname("vendor/rbs/definitely-rbs"))
+  #
+  # repo.lookup("minitest", "2.1.3") # => Pathname or nil
+  # ```
+  #
+  # If one gem version can resolve to several directories, the last added dir wins.
+  #
+  class Repository
+    class GemRBS
+      attr_reader name: String
+
+      # Array of gem dirs.
+      # Gem dir contains directories for each version.
+      attr_reader paths: Array[Pathname]
+
+      # Hash from a version to VersionPath object.
+      attr_reader versions(): Hash[Gem::Version, VersionPath]
+
+      @versions: Hash[Gem::Version, VersionPath]?
+
+      def initialize: (name: String) -> void
+
+      def load!: () -> void
+
+      def version_names: () -> Array[Gem::Version]
+
+      def oldest_version: () -> VersionPath
+
+      def latest_version: () -> VersionPath
+
+      def find_best_version: (Gem::Version?) -> VersionPath
+
+      # Returns true if versions is empty.
+      def empty?: () -> bool
+    end
+
+    class VersionPath
+      attr_reader gem: GemRBS
+      attr_reader version: Gem::Version
+      attr_reader path: Pathname
+
+      def initialize: (gem: GemRBS, version: Gem::Version, path: Pathname) -> void
+    end
+
+    DEFAULT_STDLIB_ROOT: Pathname
+
+    # Array of _root dir_s of repositories.
+    #
+    attr_reader dirs: Array[Pathname]
+
+    attr_reader gems: Hash[String, GemRBS]
+
+    def self.default: () -> instance
+
+    def self.find_best_version: (Gem::Version? version, Array[Gem::Version] candidates) -> Gem::Version
+
+    # An optional keyword argument `no_stdlib` is to skip adding directory for stdlib classes.
+    # Passing truthy value will skip loading stdlib. (You can add the stdlib root by yourself.)
+    #
+    def initialize: (?no_stdlib: bool) -> void
+
+    # Add new _root dir_ to the repository set.
+    # If two repository dirs have exactly same gem-version definitions, the latter overwrites the prior.
+    #
+    def add: (Pathname dir) -> void
+
+    # Returns a directory for given `gem` name and `version`.
+    # `version` can be `nil` for _any version_.
+    #
+    # If the given gem cannot be found, it returns `nil`.
+    #
+    def lookup: (String gem, String? version) -> Pathname?
+
+    def lookup_path: (String gem, String? version) -> [GemRBS, VersionPath]?
+  end
+end

data/sig/resolver/constant_resolver.rbs

@@ -0,0 +1,92 @@
+module RBS
+  module Resolver
+    class ConstantResolver
+      # Table stores the set of immediate child constants of a module.
+      #
+      # ```rb
+      # table = RBS::ConstantResolver::Table.new(env)
+      #
+      # table.children(TypeName.parse("::Object"))                # -> { ... }  Returns a hash of name and constants.
+      # table.children(TypeName.parse("::File::PATH_SEPARATOR"))  # -> nil      Returns nil because the constant is not a module.
+      #
+      # table.toplevel                                      # -> { ... }  Returns a hash of top level constants.
+      # ```
+      #
+      # The `#toplevel` is incompatible with Ruby.
+      # All constants in Ruby are defined under `Object`, and they are accessed with `::` (Colon3) operator.
+      # RBS is different.
+      # `::` constants are _toplevel_ constants, and they are not defined under `::Object`.
+      #
+      # The behavior is simulated in `ConstantResolver`.
+      #
+      class Table
+        attr_reader children_table: Hash[TypeName, Hash[Symbol, Constant]?]
+        attr_reader constants_table: Hash[TypeName, Constant]
+        attr_reader toplevel: Hash[Symbol, Constant]
+
+        def initialize: (Environment) -> void
+
+        def constant: (TypeName constant_name) -> Constant?
+
+        # Returns a set of constants defined under `module_name`.
+        # Returns `nil` if there is no module with given `module_name`.
+        #
+        def children: (TypeName module_name) -> Hash[Symbol, Constant]?
+
+        private
+
+        def constant_of_module: (TypeName name, Environment::ClassEntry | Environment::ModuleEntry) -> Constant
+
+        def constant_of_constant: (TypeName name, Environment::ConstantEntry) -> Constant
+      end
+
+      attr_reader builder: DefinitionBuilder
+      attr_reader table: Table
+      attr_reader context_constants_cache: Hash[context, Hash[Symbol, Constant]?]
+      attr_reader child_constants_cache: Hash[TypeName, Hash[Symbol, Constant]]
+
+      def initialize: (builder: DefinitionBuilder) -> void
+
+      # Resolves to `Constant` with given constant name `name` and `context`.
+      # Returns `nil` if the constant cannot be resolved from the context.
+      #
+      def resolve: (Symbol name, context: context) -> Constant?
+
+      # Returns the available all constants from `context`.
+      #
+      # Returns `nil` when the `context` is invalid.
+      def constants: (context) -> Hash[Symbol, Constant]?
+
+      # Resolves the module_name and constant name to `Constant`
+      #
+      # ```ruby
+      # A::B
+      # ^     <- module_name
+      #    ^  <- constant_name
+      # ```
+      #
+      def resolve_child: (TypeName module_name, Symbol constant_name) -> Constant?
+
+      # Returns the table of all constants accessible with `::` (colon2) operator.
+      #
+      # * The constants under the module are included.
+      # * The constants under the ancestor modules are included.
+      #   * The constants under the `::Object` class are not included.
+      #   * The top level constants are not included.
+      #
+      def children: (TypeName module_name) -> Hash[Symbol, Constant]
+
+      private
+
+      def load_context_constants: (context) -> void
+
+      def load_child_constants: (TypeName) -> void
+
+      def constants_from_context: (context, constants: Hash[Symbol, Constant]) -> bool
+
+      def constants_from_ancestors: (TypeName, constants: Hash[Symbol, Constant]) -> void
+
+      def constants_itself: (context, constants: Hash[Symbol, Constant]) -> void
+    end
+  end
+end

data/sig/resolver/context.rbs

@@ -0,0 +1,34 @@
+module RBS
+  module Resolver
+    # `context` represents the module nesting structure.
+    #
+    # - `nil` means toplevel
+    # - A 2-tuple represents parent and the most inner module
+    #   - `TypeName` is for a module
+    #   - `false` is for unknown module
+    #
+    # Note that the `TypeName` must be an absolute type name.
+    #
+    # The following Ruby code has context of `[[nil, TypeName.parse("::Foo")], false]` where
+    #
+    # * `Foo` is a class defined in RBS file
+    # * `Bar` is not defined in RBS files
+    #
+    # ```ruby
+    # class Foo
+    #   module Bar
+    #     # Context here
+    #   end
+    # end
+    # ```
+    #
+    # The unknown module (`false`) appears only in Ruby code.
+    # RBS modules/classes are always exists (or defines new module).
+    # Nesting a unknown module cannot happen in RBS.
+    #
+    # In Ruby this happens when the module/class is not declared in RBS files.
+    #
+    type context = [context, TypeName | false]
+                 | nil
+  end
+end

data/sig/resolver/type_name_resolver.rbs

@@ -0,0 +1,61 @@
+module RBS
+  module Resolver
+    # TypeNameResolver resolves given relative type name to absolute type name under a module nesting context.
+    #
+    # The type name resolution doesn't take account of ancestors of modules.
+    # It just ignores included modules and super classes.
+    #
+    class TypeNameResolver
+      def initialize: (Set[TypeName] all_names, Hash[TypeName, [TypeName, context]] aliases) -> void
+
+      def self.build: (Environment) -> instance
+
+      # Translates given type name to absolute type name
+      #
+      # Returns `nil` if cannot find associated type name.
+      # Module names in the type name are normalized.
+      #
+      def resolve: (TypeName, context: context) -> TypeName?
+
+      # Translates given type name to absolute type name
+      #
+      # Returns `false` if a cycle is detected while resolving aliases.
+      # Returns `nil` if the type name cannot be resolved.
+      #
+      def resolve_namespace: (TypeName, context: context) -> (TypeName | false | nil)
+
+      private
+
+      attr_reader all_names: Set[TypeName]
+
+      attr_reader aliases: Hash[TypeName, [TypeName, context]]
+
+      attr_reader cache: Hash[context, Hash[TypeName, TypeName?]]
+
+      # Returns the type name if it exists in `all_names` (normalized)
+      #
+      def has_type_name?: (TypeName) -> TypeName?
+
+      # Returns the type name if it is an alias (not normalized)
+      #
+      def aliased_name?: (TypeName) -> TypeName?
+
+      def try_cache: (TypeName, context) { () -> TypeName? } -> TypeName?
+
+      # Translates the head module name in the context and returns an absolute type name
+      #
+      # Returns `nil` if cannot find associated type name.
+      # The returned namespace may be an alias
+      #
+      def resolve_head_namespace: (Symbol, context) -> TypeName?
+
+      # Resolves the type name in the given context
+      #
+      def resolve_type_name: (Symbol, context) -> TypeName?
+
+      def resolve_namespace0: (TypeName, context, Set[TypeName]) -> (TypeName | false | nil)
+
+      def normalize_namespace: (TypeName, TypeName rhs, context, Set[TypeName]) -> (TypeName | false | nil)
+    end
+  end
+end

data/sig/rewriter.rbs

@@ -0,0 +1,45 @@
+module RBS
+  # Rewriter performs targeted character-range replacements on Buffer content.
+  #
+  # Unlike Writer which regenerates entire source from AST, Rewriter preserves
+  # everything outside the rewritten ranges, including non-documentation comments.
+  #
+  # Rewrite requests are buffered and applied all at once when `#string` is called.
+  #
+  class Rewriter
+    attr_reader buffer: Buffer
+
+    # Initialize with a toplevel buffer.
+    # Raises if the buffer has a parent (non-toplevel).
+    #
+    def initialize: (Buffer buffer) -> void
+
+    # Register a rewrite request for the given location.
+    #
+    def rewrite: (Location[untyped, untyped] location, String string) -> self
+
+    # Add a new comment before the earliest of the given locations.
+    #
+    def add_comment: (*Location[untyped, untyped] locations, content: String) -> self
+
+    # Replace an existing comment's content.
+    #
+    def replace_comment: (AST::Comment comment, content: String) -> self
+
+    # Delete an existing comment.
+    #
+    def delete_comment: (AST::Comment comment) -> self
+
+    # Apply all buffered rewrites and return the resulting string.
+    #
+    # Raises if any rewrite ranges overlap.
+    #
+    def string: () -> String
+
+    private
+
+    def format_comment: (String content, String indent) -> String
+
+    @rewrites: Array[[Location[untyped, untyped], String]]
+  end
+end

data/sig/shims/bundler.rbs

@@ -0,0 +1,38 @@
+module Bundler
+  class LockfileParser
+    def initialize: (String) -> void
+
+    def specs: () -> Array[LazySpecification]
+  end
+
+  class LazySpecification
+    def name: () -> String
+
+    def version: () -> String
+
+    def dependencies: () -> Array[Gem::Dependency]
+  end
+
+  class Dependency < Gem::Dependency
+    attr_reader autorequire: Array[String]?
+
+    attr_reader source: untyped
+  end
+
+  class Definition
+    def lockfile: () -> Pathname
+
+    def locked_gems: () -> LockfileParser
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  def self.default_lockfile: () -> Pathname
+
+  def self.definition: () -> Definition
+
+  module Source
+    class Gemspec
+    end
+  end
+end

data/sig/shims/enumerable.rbs

@@ -0,0 +1,5 @@
+module Enumerable[unchecked out Elem] : _Each[Elem]
+  def each_slice: (2) { ([Elem, Elem]) -> void } -> void
+                | (2) -> Enumerator[[Elem, Elem], void]
+                | ...
+end

data/sig/shims/rubygems.rbs

@@ -0,0 +1,19 @@
+module Gem
+  class Specification
+    attr_reader version (): Version
+
+    attr_reader gem_dir (): String
+
+    def self.find_by_name: (String name, *String requirements) -> instance
+
+    def dependencies: () -> Array[Dependency]
+  end
+
+  class Dependency
+    def name: () -> String
+  end
+
+  module ::Kernel
+    def self?.gem: (String, *String) -> void
+  end
+end