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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/prototype/rb.rbs

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/prototype/rbi.rbs

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/prototype/runtime.rbs

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

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

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

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

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

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

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/resolver/constant_resolver.rbs

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/resolver/context.rbs

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

package/lib/ruby/gems/3.4.0/gems/rbs-3.8.0/sig/resolver/type_name_resolver.rbs

@@ -1,35 +0,0 @@
-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
-      type query = [TypeName, context]
-
-      def initialize: (Environment) -> void
-
-      # Translates given type name to absolute type name.
-      # Returns `nil` if cannot find associated type name.
-      #
-      def resolve: (TypeName, context: context) -> TypeName?
-
-      private
-
-      attr_reader env: Environment
-
-      attr_reader all_names: Set[TypeName]
-
-      attr_reader cache: Hash[query, TypeName?]
-
-      def has_name?: (TypeName) -> TypeName?
-
-      def try_cache: (query) { () -> TypeName? } -> TypeName?
-
-      def resolve_in: (Symbol, context) -> TypeName?
-
-      def partition: (TypeName) -> [Symbol, TypeName?]
-    end
-  end
-end