@ai-ecoverse/wasix-ruby 3.4.11-2 → 3.4.11-20

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/environment.rbs

@@ -1,277 +0,0 @@
-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 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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/environment_loader.rbs

@@ -1,111 +0,0 @@
-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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/environment_walker.rbs

@@ -1,65 +0,0 @@
-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