rbs 4.1.0.pre.2-java

data/sig/diff.rbs

@@ -0,0 +1,28 @@
+module RBS
+  class Diff
+    @type_name: TypeName
+    @library_options: RBS::CLI::LibraryOptions
+    @after_path: Array[String]
+    @before_path: Array[String]
+    @detail: boolish
+
+    def initialize: (
+      type_name: TypeName,
+      library_options: RBS::CLI::LibraryOptions,
+      ?after_path: Array[String],
+      ?before_path: Array[String],
+      ?detail: boolish
+    ) -> void
+
+    def each_diff: () { (String before, String after) -> void } -> void
+
+    private def each_diff_by: (Symbol kind, Hash[::Symbol, Definition::Method] before_methods, Hash[::Symbol, Definition::Method] after_methods) { (String before, String after) -> void } -> void
+    private def build_methods: (Array[String] path) -> [ Hash[::Symbol, Definition::Method], Hash[::Symbol, Definition::Method] , Hash[Symbol, Constant]]
+    private def build_env: (Array[String] path) -> Environment
+    private def build_builder: (Environment env) -> DefinitionBuilder
+    private def definition_method_to_s: (Symbol key, Symbol kind, Definition::Method definition_method) -> String?
+    private def each_diff_methods: (Symbol kind, Hash[Symbol, Definition::Method], Hash[Symbol, Definition::Method]) { (String before, String after) -> void } -> void
+    private def each_diff_constants: (Hash[Symbol, Constant] before_constants, Hash[Symbol, Constant] after_constants) { (String before, String after) -> void } -> void
+    private def constant_to_s: (Constant?) -> String
+  end
+end

data/sig/directives.rbs

@@ -0,0 +1,77 @@
+module RBS
+  module AST
+    module Directives
+      type t = Use | ResolveTypeNames
+
+      class Base
+      end
+
+      # ```
+      # use Foo, Foo::Bar as FBar, Foo:Baz::*
+      # ```
+      #
+      class Use < Base
+        type clause = SingleClause | WildcardClause
+
+        class SingleClause
+          # Foo::Bar
+          # ^^^^^^^^       type_name
+          #
+          # Foo::Bar as X
+          #          ^^    keyword
+          #             ^  new_name
+          #
+          type loc = Location[:type_name, :keyword | :new_name]
+
+          attr_reader type_name: TypeName
+
+          attr_reader new_name: Symbol?
+
+          attr_reader location: loc?
+
+          def initialize: (type_name: TypeName, new_name: Symbol?, location: loc?) -> void
+        end
+
+        class WildcardClause
+          # Foo::Bar::*
+          # ^^^^^^^^^^    namespace
+          #           ^   star
+          #
+          type loc = Location[:namespace | :star, bot]
+
+          attr_reader namespace: Namespace
+
+          attr_reader location: loc?
+
+          def initialize: (namespace: Namespace, location: loc?) -> void
+        end
+
+        # use Foo
+        # ^^^       keyword
+        type loc = Location[:keyword, bot]
+
+        attr_reader clauses: Array[clause]
+
+        attr_reader location: loc?
+
+        def initialize: (clauses: Array[clause], location: loc?) -> void
+      end
+
+      class ResolveTypeNames < Base
+        # ```
+        # # resolve-type-names: false
+        #   ^^^^^^^^^^^^^^^^^^          keyword
+        #                     ^         colon
+        #                       ^^^^^   value
+        # ```
+        type loc = Location[:keyword | :colon | :value, bot]
+
+        attr_reader location: loc?
+
+        attr_reader value: bool
+
+        def initialize: (value: bool, location: loc?) -> void
+      end
+    end
+  end
+end

data/sig/environment/class_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ClassEntry.new(TypeName.parse("::String"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Kernel")], declaration]
+    # ```
+    class ClassEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Class | AST::Ruby::Declarations::ClassDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      @primary_decl: declaration?
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Find the *primary* declaration of the class
+      #
+      # * Returns the first declaration with super class
+      # * Returns the first declaration if the declaration doesn't have super class
+      #
+      %a{pure} def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+    end
+  end
+end

data/sig/environment/module_entry.rbs

@@ -0,0 +1,50 @@
+module RBS
+  class Environment
+    # Represents a class entry in the environment
+    #
+    # ```rb
+    # entry = ModuleEntry.new(TypeName.parse("::Kernel"))
+    # entry << [nil, declaration]
+    # entry << [[nil, TypeName.parse("::Object")], declaration]
+    # ```
+    #
+    class ModuleEntry
+      attr_reader name: TypeName
+
+      type declaration = AST::Declarations::Module | AST::Ruby::Declarations::ModuleDecl
+
+      type context_decl = [Resolver::context, declaration]
+
+      attr_reader context_decls: Array[context_decl]
+
+      def initialize: (TypeName) -> void
+
+      def <<: (context_decl) -> self
+
+      def each_decl: { (declaration) -> void } -> void
+                   | () -> Enumerator[declaration]
+
+      # Returns true if the entry doesn't have any declaration
+      #
+      def empty?: () -> bool
+
+      # Returns the first declaration
+      #
+      # This method helps using the class with `ClassEntry` objects.
+      #
+      def primary_decl: () -> declaration
+
+      # Returns the generics declaration
+      #
+      def type_params: () -> Array[AST::TypeParam]
+
+      # Confirms if the type parameters in the declaration are compatible
+      #
+      # * Raises `GenericParameterMismatchError` if incompatible declaration is detected.
+      #
+      def validate_type_params: () -> void
+
+      def self_types: () -> Array[AST::Declarations::Module::Self]
+    end
+  end
+end

data/sig/environment.rbs

@@ -0,0 +1,286 @@
+module RBS
+  class Environment
+    type module_decl = AST::Declarations::Class | AST::Declarations::Module
+
+    # Name of object, it's (single) declaration, and the outer module declarations
+    #
+    class SingleEntry[N, D]
+      attr_reader name: N
+      attr_reader decl: D
+      attr_reader context: Resolver::context
+
+      def initialize: (name: N, decl: D, context: Resolver::context) -> void
+    end
+
+    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias | AST::Ruby::Declarations::ClassModuleAliasDecl]
+    end
+
+    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias | AST::Ruby::Declarations::ClassModuleAliasDecl]
+    end
+
+    class InterfaceEntry < SingleEntry[TypeName, AST::Declarations::Interface]
+    end
+
+    class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
+    end
+
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant | AST::Ruby::Declarations::ConstantDecl]
+    end
+
+    class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]
+    end
+
+    # Top level declarations
+    def declarations: () -> Array[AST::Ruby::Declarations::t | AST::Declarations::t]
+
+    # Array of source objects loaded in the environment
+    #
+    attr_reader sources: Array[Source::t]
+
+    # Class declarations
+    attr_reader class_decls: Hash[TypeName, ModuleEntry | ClassEntry]
+
+    attr_reader class_alias_decls: Hash[TypeName, ModuleAliasEntry | ClassAliasEntry]
+
+    # Interface declarations
+    attr_reader interface_decls: Hash[TypeName, InterfaceEntry]
+
+    # Type alias declarations
+    attr_reader type_alias_decls: Hash[TypeName, TypeAliasEntry]
+
+    # Constant declarations
+    attr_reader constant_decls: Hash[TypeName, ConstantEntry]
+
+    # Global declarations
+    attr_reader global_decls: Hash[Symbol, GlobalEntry]
+
+    def initialize: () -> void
+
+    def initialize_copy: (Environment) -> void
+
+    # Construct an environment from EnvironmentLoader
+    #
+    def self.from_loader: (EnvironmentLoader) -> Environment
+
+    def add_source: (Source::t) -> void
+
+    def each_rbs_source: () { (Source::RBS) -> void } -> void
+                      | () -> Enumerator[Source::RBS]
+
+    def each_ruby_source: () { (Source::Ruby) -> void } -> void
+                        | () -> Enumerator[Source::Ruby]
+
+    # Insert a declaration into the environment
+    #
+    private def insert_rbs_decl: (AST::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
+
+    # Insert a declaration into the environment
+    #
+    private def insert_ruby_decl: (AST::Ruby::Declarations::t, context: Resolver::context, namespace: Namespace) -> void
+
+    # Resolve all type names in the environment to absolute type names.
+    # Relative type name will be left if absolute type name cannot be found.
+    #
+    # When `only` is given, it skips other _top-level_ declarations not included in the collection.
+    # This helps running resolution faster in the case of _partial updates_.
+    #
+    def resolve_type_names: (?only: Set[AST::Declarations::t | AST::Ruby::Declarations::t]?) -> Environment
+
+    def resolve_signature: (
+      Resolver::TypeNameResolver,
+      UseMap::Table,
+      Array[AST::Directives::t],
+      Array[AST::Declarations::t],
+      ?only: Set[AST::Declarations::t | AST::Ruby::Declarations::t]?
+    ) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
+
+    def inspect: () -> String
+
+    def buffers: () -> Array[Buffer]
+
+    # Remove declarations and directives that are loaded from `buffers`
+    #
+    def unload: (Set[Pathname] paths) -> Environment
+              | %a{deprecated: Use pathname version} (Set[Buffer] buffers) -> Environment
+
+    # Returns true if an interface with the type name is defined
+    #
+    def interface_name?: (TypeName) -> bool
+
+    # Returns true if a type alias with the type name is defined
+    #
+    def type_alias_name?: (TypeName) -> bool
+
+    # Returns true if a module or class with the type name is defined
+    #
+    def module_name?: (TypeName) -> bool
+
+    # Returns true if the type name is defined
+    #
+    def type_name?: (TypeName) -> bool
+
+    # Returns if a constant of the name is defined
+    #
+    def constant_name?: (TypeName) -> bool
+
+    # Returns true if the type name is defined by constant declaration
+    #
+    def constant_decl?: (TypeName) -> bool
+
+    # Returns true if the type name is defined by class declaration
+    #
+    def class_decl?: (TypeName) -> bool
+
+    # Returns true if the type name is defined by module declaration
+    #
+    def module_decl?: (TypeName) -> bool
+
+    # Returns true if the type name is a module alias
+    #
+    def module_alias?: (TypeName) -> bool
+
+    # Returns true if the type name is a class alias
+    def class_alias?: (TypeName) -> bool
+
+    # Returns the entry for the class name
+    #
+    # Returns `nil` when:
+    #
+    # * The type name is not found
+    # * The type name is not a class
+    #
+    # It normalizes when `normalized: true` is given -- returns `ClassEntry` or `nil`.
+    #
+    def class_entry: (TypeName, normalized: true) -> ClassEntry?
+                   | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | nil)
+
+    # Returns ClassEntry if the class definition is found, normalized in case of alias
+    #
+    %a{deprecated: Use `class_entry(type_name, normalized: true)` instead. }
+    def normalized_class_entry: (TypeName) -> ClassEntry?
+
+    # Returns the entry for the module name
+    #
+    # Returns `nil` when:
+    #
+    # * The type name is not found
+    # * The type name is not a module
+    #
+    # It normalizes when `normalized: true` is given -- returns `ModuleEntry` or `nil`.
+    #
+    def module_entry: (TypeName, normalized: true) -> ModuleEntry?
+                    | (TypeName, ?normalized: bool) -> (ModuleEntry | ModuleAliasEntry | nil)
+
+    # Returns ModuleEntry if the module definition is found, normalized in case of alias
+    #
+    %a{deprecated: Use `module_entry(type_name, normalized: true)` instead. }
+    def normalized_module_entry: (TypeName) -> ModuleEntry?
+
+    # Returns the entry for the type name
+    #
+    # The entry is one of ClassEntry, ModuleEntry, ConstantEntry, ClassAliasEntry, or ModuleAliasEntry.
+    # When `normalized: true` is given, it returns normalized entry -- one of ClassEntry, ModuleEntry, or ConstantEntry.
+    #
+    # Returns `nil` if not found.
+    #
+    def constant_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | ConstantEntry | nil)
+                      | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+
+    # Returns ClassEntry or ModuleEntry if the class/module definition is found
+    #
+    # Normalizes when `normalized: true` is given.
+    #
+    def module_class_entry: (TypeName, normalized: true) -> (ClassEntry | ModuleEntry | nil)
+                          | (TypeName, ?normalized: bool) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
+
+    %a{deprecated: Use `module_class_entry(type_name, normalized: true)` instead. }
+    def normalized_module_class_entry: (TypeName) -> (ClassEntry | ModuleEntry | nil)
+
+    @normalize_module_name_cache: Hash[TypeName, TypeName | false | nil]
+
+    # Returns the original module name that is defined with `module` declaration
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns `nil` if the rhs name cannot be found
+    # * Returns `false` if the name is cyclic
+    #
+    # Note that this method assumes the declarations have resolved type names.
+    #
+    def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Returns the original module name that is defined with `module`/`class` declaration
+    #
+    # * Raises an error if given type name is not module/class
+    # * Calls `#absolute!` for relative module names
+    # * Returns the name itself if the name cannot be normalized to a class/module
+    #
+    # Note that this method assumes the declarations have resolved type names.
+    #
+    def normalize_module_name: (TypeName) -> TypeName
+
+    # Returns the original module name that is defined with `module`/`class` declaration
+    #
+    # * Raises an error if given type name is not a module/class
+    def normalize_module_name!: (TypeName) -> TypeName
+
+    # Returns a normalized module/class name or a type name with a normalized namespace
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns `nil` if the typename cannot be found
+    # * Returns `false` if the name is cyclic
+    #
+    # Note that this method assumes the declarations have resolved type names.
+    #
+    def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Normalize the type name or raises an error
+    #
+    # Note that this method assumes the declarations have resolved type names.
+    #
+    def normalize_type_name!: (TypeName) -> TypeName
+
+    # Returns a normalized module/class name or a type name with a normalized namespace
+    #
+    # * Calls `#absolute!` for relative module names
+    # * Returns the typename itself if the name cannot be normalized
+    #
+    # Note that this method assumes the declarations have resolved type names.
+    #
+    def normalize_type_name: (TypeName) -> TypeName
+
+    # Returns `true` if given type name is normalized
+    #
+    def normalized_type_name?: (TypeName) -> bool
+
+    # Returns the given type name if it's normalized, or raises
+    #
+    def normalized_type_name!: (TypeName) -> TypeName
+
+    # Runs generics type params validation over each class definitions
+    def validate_type_params: () -> void
+
+    private
+
+    # Returns a context for inside given decls
+    #
+    def resolver_context: (*module_decl) -> Resolver::context
+
+    def append_context: (Resolver::context, module_decl) -> Resolver::context
+
+    def resolve_declaration: (Resolver::TypeNameResolver resolver, UseMap map, AST::Declarations::t decl, context: Resolver::context, prefix: Namespace) -> AST::Declarations::t
+
+    def resolve_member: (Resolver::TypeNameResolver, UseMap map, AST::Members::t, context: Resolver::context) -> AST::Members::t
+
+    def resolve_method_type: (Resolver::TypeNameResolver, UseMap map, RBS::MethodType, context: Resolver::context) -> RBS::MethodType
+
+    def resolve_type_params: (Resolver::TypeNameResolver resolver, UseMap map, Array[AST::TypeParam], context: Resolver::context) ->  Array[AST::TypeParam]
+
+    def resolve_ruby_decl: (Resolver::TypeNameResolver, AST::Ruby::Declarations::t, context: Resolver::context, prefix: Namespace) -> AST::Ruby::Declarations::t
+
+    def resolve_ruby_member: (Resolver::TypeNameResolver, AST::Ruby::Members::t, context: Resolver::context) -> AST::Ruby::Members::t
+
+    def absolute_type: (Resolver::TypeNameResolver, UseMap? map, Types::t, context: Resolver::context) -> Types::t
+
+    def absolute_type_name: (Resolver::TypeNameResolver, UseMap? map, TypeName, context: Resolver::context) -> TypeName
+  end
+end

data/sig/environment_loader.rbs

@@ -0,0 +1,111 @@
+module RBS
+  # EnvironmentLoader is an object to load RBS files from filesystem.
+  #
+  # Set up your configuration through repository and `#add` method.
+  #
+  # ```ruby
+  # # Set up the repository to load library RBSs from.
+  # repo = RBS::Repository.default
+  # repo.add(Pathname("vendor/rbs/gem-rbs"))
+  # repo.add(Pathname("vendor/rbs/internal-rbs"))
+  #
+  # loader = RBS::EnvironmentLoader.new(repository: repo)
+  #
+  # # Add libraries to load RBS files.
+  # loader.add(library: "minitest")
+  # loader.add(library: "rbs", version: "1.0.0")
+  #
+  # # Add dirs to load RBS files from.
+  # loader.add(path: Pathname("sig"))
+  #
+  # # Load RBSs into an environment.
+  # environment = RBS::Environment.new()
+  # loader.load(env: environment)
+  # ```
+  #
+  class EnvironmentLoader
+    class UnknownLibraryError < StandardError
+      attr_reader library: Library
+
+      def initialize: (lib: Library) -> void
+    end
+
+    class Library
+      attr_reader name: String
+      attr_reader version: String?
+
+      def initialize: (name: String, version: String?) -> void
+    end
+
+    include FileFinder
+
+    DEFAULT_CORE_ROOT: Pathname
+
+    attr_reader core_root: Pathname?
+    attr_reader repository: Repository
+
+    attr_reader libs: Set[Library]
+    attr_reader dirs: Array[Pathname]
+
+    # The source where the RBS comes from.
+    #
+    # `:core` means it is part of core library.
+    # `Library` means it is from library.
+    # `Pathname` means it is loaded from a directory.
+    #
+    type source = :core
+                | Library
+                | Pathname
+
+    # Accepts two optional keyword arguments.
+    #
+    # `core_root` is the path to the directory with RBSs for core classes.
+    # The default value is the core library included in RBS gem. (EnvironmentLoader::DEFAULT_CORE_ROOT)
+    # Passing `nil` means it skips loading core class definitions.
+    #
+    # `repository` is the repository for library classes.
+    # The default value is repository only with stdlib classes. (Repository.new)
+    #
+    def initialize: (?core_root: Pathname?, ?repository: Repository) -> void
+
+    # Add a path or library to load RBSs from.
+    #
+    # `path` can be a file or a directory.
+    # All `.rbs` files from the given directory will be loaded.
+    # Specifying a file will load the file regardless the extension of the file is.
+    #
+    # `library` can be a name of a gem.
+    # Specifying `nil` to `version` will load any version available.
+    # It first tries to load RBS files from gem with specified version.
+    # If RBS files cannot be found in the gem, it tries to load RBSs from repository.
+    #
+    def add: (path: Pathname) -> void
+           | (library: String, version: String?, ?resolve_dependencies: boolish) -> void
+
+    def resolve_dependencies: (library: String, version: String?) -> void
+
+    # Add repository path and libraries via rbs_collection.lock.yaml.
+    def add_collection: (Collection::Config::Lockfile lockfile) -> void
+
+    # This is helper function to test if RBS for a library is available or not.
+    #
+    def has_library?: (library: String, version: String?) -> bool
+
+    # Add all declarations to environment.
+    #
+    # Raises `UnknownLibraryError` if RBS cannot be loaded from a library.
+    #
+    # Returns an array of tuples of the declaration, path to the file, and the source.
+    #
+    def load: (env: Environment) -> Array[[AST::Declarations::t, Pathname, source]]
+
+    # Returns a pair of spec and path for a gem with RBS.
+    # Returns nil if the gem is not installed, or the gem doesn't provide RBS.
+    #
+    def self.gem_sig_path: (String name, String? version) -> [Gem::Specification, Pathname]?
+
+    def each_signature: () { (source, Pathname, Buffer, Array[AST::Declarations::t], Array[AST::Directives::t]) -> void } -> void
+
+    def each_dir: { (source, Pathname) -> void } -> void
+  end
+end

data/sig/environment_walker.rbs

@@ -0,0 +1,65 @@
+module RBS
+  # EnvironmentWalker provides topological sort of class/module definitions.
+  #
+  # If a method, attribute, or ancestor in a class definition have a reference to another class, it is dependency.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env)
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
+  # The `#only_ancestors!` method limits the dependency only to ancestors.
+  # Only super classes and included modules are dependencies with the option.
+  # This is useful to calculate the dependencies of class hierarchy.
+  #
+  # ```rb
+  # walker = EnvironmentWalker.new(env: env).only_ancestors!
+  #
+  # walker.each_strongly_connected_component do |scc|
+  #   # Yields an array of strongly connected components.
+  # end
+  # ```
+  #
+  class EnvironmentWalker
+    class InstanceNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class SingletonNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    class TypeNameNode
+      attr_reader type_name: TypeName
+      def initialize: (type_name: TypeName) -> void
+    end
+
+    attr_reader env: Environment
+    attr_reader only_ancestors: bool
+    attr_reader builder: DefinitionBuilder
+
+    def initialize: (env: Environment) -> void
+
+    def only_ancestors!: (?bool only) -> self
+
+    def only_ancestors?: () -> bool
+
+    type node = InstanceNode | SingletonNode | TypeNameNode
+    include TSort[node]
+
+    def tsort_each_node: () { (node) -> void } -> void
+
+    def tsort_each_child: (node) { (node) -> void } -> void
+
+    private
+
+    def each_type_name: (Types::t) { (TypeName) -> void } -> void
+
+    def each_type_node: (Types::t) { (node) -> void } -> void
+  end
+end