rbs-relaxed 3.9.0.1

data/sig/environment.rbs

@@ -0,0 +1,279 @@
+module RBS
+  class Environment
+    type module_decl = AST::Declarations::Class | AST::Declarations::Module
+
+    interface _ModuleOrClass
+      def name: () -> TypeName
+
+      def type_params: () -> Array[AST::TypeParam]
+    end
+
+    interface _NamedDecl
+      def name: () -> TypeName
+    end
+
+    module ContextUtil
+      def calculate_context: (Array[_NamedDecl]) -> Resolver::context
+    end
+
+    # Name of object, it's (multiple) declarations with the outer module declarations
+    #
+    class MultiEntry[M < _ModuleOrClass]
+      class D[M < _ModuleOrClass]
+        attr_reader decl: M
+        attr_reader outer: Array[module_decl]
+
+        def initialize: (decl: M, outer: Array[module_decl]) -> void
+
+        include ContextUtil
+
+        @context: Resolver::context
+
+        def context: () -> Resolver::context
+      end
+
+      attr_reader name: TypeName
+      attr_reader decls: Array[D[M]]
+
+      @primary: D[M]?
+
+      def initialize: (name: TypeName) -> void
+
+      def insert: (decl: M, outer: Array[module_decl]) -> void
+
+      def validate_type_params: () -> void
+
+      def compatible_params?: (Array[AST::TypeParam], Array[AST::TypeParam]) -> boolish
+
+      def type_params: () -> Array[AST::TypeParam]
+
+      def primary: () -> D[M]
+    end
+
+    class ModuleEntry < MultiEntry[AST::Declarations::Module]
+      def self_types: () -> Array[AST::Declarations::Module::Self]
+    end
+
+    class ClassEntry < MultiEntry[AST::Declarations::Class]
+    end
+
+    # 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 outer: Array[module_decl]
+
+      def initialize: (name: N, decl: D, outer: Array[module_decl]) -> void
+
+      include ContextUtil
+
+      @context: Resolver::context
+
+      def context: () -> Resolver::context
+    end
+
+    class ModuleAliasEntry < SingleEntry[TypeName, AST::Declarations::ModuleAlias]
+    end
+
+    class ClassAliasEntry < SingleEntry[TypeName, AST::Declarations::ClassAlias]
+    end
+
+    class InterfaceEntry < SingleEntry[TypeName, AST::Declarations::Interface]
+    end
+
+    class TypeAliasEntry < SingleEntry[TypeName, AST::Declarations::TypeAlias]
+    end
+
+    class ConstantEntry < SingleEntry[TypeName, AST::Declarations::Constant]
+    end
+
+    class GlobalEntry < SingleEntry[Symbol, AST::Declarations::Global]
+    end
+
+    # Top level declarations
+    attr_reader declarations: Array[AST::Declarations::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]
+
+    # A hash from Buffer to it's contents
+    #
+    attr_reader signatures: Hash[Buffer, [Array[AST::Directives::t], Array[AST::Declarations::t]]]
+
+    def initialize: () -> void
+
+    def initialize_copy: (Environment) -> void
+
+    # Construct an environment from EnvironmentLoader
+    #
+    def self.from_loader: (EnvironmentLoader) -> Environment
+
+    def add_signature: (buffer: Buffer, directives: Array[AST::Directives::t], decls: Array[AST::Declarations::t]) -> void
+
+    # Insert a toplevel declaration into the environment
+    #
+    def <<: (AST::Declarations::t decl) -> self
+
+    # Insert a declaration into the environment
+    #
+    private def insert_decl: (AST::Declarations::t, outer: Array[module_decl], 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]?) -> Environment
+
+    def resolve_signature: (Resolver::TypeNameResolver, UseMap::Table, Array[AST::Directives::t], Array[AST::Declarations::t], ?only: Set[AST::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[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
+
+    def class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | nil)
+
+    # Returns ClassEntry if the class definition is found, normalized in case of alias
+    #
+    def normalized_class_entry: (TypeName) -> ClassEntry?
+
+    def module_entry: (TypeName) -> (ModuleEntry | ModuleAliasEntry | nil)
+
+    # Returns ModuleEntry if the module definition is found, normalized in case of alias
+    #
+    def normalized_module_entry: (TypeName) -> ModuleEntry?
+
+    def constant_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | ConstantEntry | nil)
+
+    def module_class_entry: (TypeName) -> (ClassEntry | ClassAliasEntry | ModuleEntry | ModuleAliasEntry | nil)
+
+    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
+    #
+    def normalize_module_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Returns the original module name that is defined with `module` declaration
+    #
+    # * Raises an error if given type name is not module
+    # * Calls `#absolute!` for relative module names
+    # * Returns the name itself if the name cannot be normalized to a class/module
+    #
+    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
+    #
+    def normalize_type_name?: (TypeName) -> (TypeName | nil | false)
+
+    # Normalize the type name or raises an error
+    #
+    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
+    #
+    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, outer: Array[module_decl], 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 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