@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/ancestor_builder.rbs

@@ -1,163 +0,0 @@
-module RBS
-  class DefinitionBuilder
-    # AncestorBuilder calculates the ancestors of a class or module.
-    #
-    class AncestorBuilder
-      # OneAncestors represents a list of _direct_ ancestors of a type name
-      #
-      # _Direct_ ancestors is defined as follows:
-      #
-      # * Super class is a direct ancestor
-      # * Self type constraints are direct ancestors
-      # * Mixin modules are direct ancestors
-      # * Mixin interfaces are direct ancestors
-      #
-      # The optional attributes are defined by the type of the ancestors object, one of the following five groups:
-      #
-      # 1. Instance of a class -- with super_class, included_modules, included_interfaces, and prepended_modules
-      # 2. Instance of a module -- with self_types, included_modules, included_interfaces, and prepended_modules
-      # 3. Singleton of a class or module -- with super_class, extended_modules, and extended_interfaces
-      # 4. Interface -- with included_interfaces
-      #
-      class OneAncestors
-        attr_reader type_name: TypeName
-        attr_reader params: Array[Symbol]?
-
-        # Returns super_class ancestor if specified
-        #
-        # * Always `nil` if this is not a class.
-        #
-        attr_reader super_class: Definition::Ancestor::t?
-
-        # Returns list of _self type constraints_ of a module
-        #
-        # * Returns `nil` if it is not a module instance.
-        #
-        attr_reader self_types: Array[Definition::Ancestor::Instance]?
-
-        # Returns the list of included modules
-        #
-        # * Returns `nil` if it is an interface or it is a singleton.
-        #
-        attr_reader included_modules: Array[Definition::Ancestor::Instance]?
-
-        # Returns the list of included interfaces
-        #
-        # * Returns `nil` it it is a singleton.
-        #
-        attr_reader included_interfaces: Array[Definition::Ancestor::Instance]?
-
-        # Returns the list of prepended modules
-        #
-        # * Returns `nil` if it is an interface or it is a singleton.
-        #
-        attr_reader prepended_modules: Array[Definition::Ancestor::Instance]?
-
-        # Returns the list of extended modules
-        #
-        # * Returns `nil` if it is an interface or it is an instance.
-        #
-        attr_reader extended_modules: Array[Definition::Ancestor::Instance]?
-
-        # Returns the list of extended interfaces
-        #
-        # * Returns `nil` if it is an interface or it is an instance.
-        #
-        attr_reader extended_interfaces: Array[Definition::Ancestor::Instance]?
-
-        def initialize: (type_name: TypeName,
-                            params: Array[Symbol]?,
-                       super_class: Definition::Ancestor::t?,
-                        self_types: Array[Definition::Ancestor::Instance]?,
-                  included_modules: Array[Definition::Ancestor::Instance]?,
-               included_interfaces: Array[Definition::Ancestor::Instance]?,
-                 prepended_modules: Array[Definition::Ancestor::Instance]?,
-                  extended_modules: Array[Definition::Ancestor::Instance]?,
-               extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
-
-        def each_ancestor: { (Definition::Ancestor::t) -> void } -> void
-                         | -> Enumerator[Definition::Ancestor::t, void]
-
-        # Returns a OneAncestors object for class instance
-        def self.class_instance: (type_name: TypeName, params: Array[Symbol], super_class: Definition::Ancestor::t?) -> instance
-
-        # Returns a OneAncestors object for module instance
-        def self.module_instance: (type_name: TypeName, params: Array[Symbol]) -> instance
-
-        # Returns a OneAncestors object for class/module singleton
-        def self.singleton: (type_name: TypeName, super_class: Definition::Ancestor::t) -> instance
-
-        # Returns a OneAncestors object for interface
-        def self.interface: (type_name: TypeName, params: Array[Symbol]) -> instance
-
-        def each_included_module: () { (Definition::Ancestor::Instance) -> void } -> void
-                                | () -> Enumerator[Definition::Ancestor::Instance, void]
-
-        def each_included_interface: () { (Definition::Ancestor::Instance) -> void } -> void
-                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
-
-        def each_prepended_module: () { (Definition::Ancestor::Instance) -> void } -> void
-                                 | () -> Enumerator[Definition::Ancestor::Instance, void]
-
-        def each_extended_module: () { (Definition::Ancestor::Instance) -> void } -> void
-                                | () -> Enumerator[Definition::Ancestor::Instance, void]
-
-        def each_extended_interface: () { (Definition::Ancestor::Instance) -> void } -> void
-                                   | () -> Enumerator[Definition::Ancestor::Instance, void]
-
-        def each_self_type: () { (Definition::Ancestor::Instance) -> void } -> void
-                          | () -> Enumerator[Definition::Ancestor::Instance, void]
-      end
-
-      attr_reader env: Environment
-
-      attr_reader one_instance_ancestors_cache: Hash[TypeName, OneAncestors]
-      attr_reader instance_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
-
-      attr_reader one_singleton_ancestors_cache: Hash[TypeName, OneAncestors]
-      attr_reader singleton_ancestors_cache: Hash[TypeName, Definition::SingletonAncestors]
-
-      attr_reader one_interface_ancestors_cache: Hash[TypeName, OneAncestors]
-      attr_reader interface_ancestors_cache: Hash[TypeName, Definition::InstanceAncestors]
-
-      def initialize: (env: Environment) -> void
-
-      def instance_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
-
-      def singleton_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::SingletonAncestors
-
-      def interface_ancestors: (TypeName, ?building_ancestors: Array[Definition::Ancestor::t]) -> Definition::InstanceAncestors
-
-      def one_instance_ancestors: (TypeName) -> OneAncestors
-
-      def one_singleton_ancestors: (TypeName) -> OneAncestors
-
-      def one_interface_ancestors: (TypeName) -> OneAncestors
-
-      private
-
-      def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
-
-      def mixin_ancestors: (Environment::ClassEntry | Environment::ModuleEntry,
-                            TypeName,
-                            included_modules: Array[Definition::Ancestor::Instance]?,
-                         included_interfaces: Array[Definition::Ancestor::Instance]?,
-                           prepended_modules: Array[Definition::Ancestor::Instance]?,
-                            extended_modules: Array[Definition::Ancestor::Instance]?,
-                         extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
-
-      def mixin_ancestors0: (AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface,
-                             TypeName,
-                             align_params: Substitution?,
-                         included_modules: Array[Definition::Ancestor::Instance]?,
-                      included_interfaces: Array[Definition::Ancestor::Instance]?,
-                        prepended_modules: Array[Definition::Ancestor::Instance]?,
-                         extended_modules: Array[Definition::Ancestor::Instance]?,
-                      extended_interfaces: Array[Definition::Ancestor::Instance]?) -> void
-
-      # Fill `#source` of instance ancestor if `ancestor.name == name` and its `source` is `nil`
-      #
-      def fill_ancestor_source: (Definition::Ancestor::t, name: TypeName, source: Definition::Ancestor::Instance::source)  -> Definition::Ancestor::t
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-module RBS
-  # AncestorGraph is a utility class that helps iterating through ancestors and descendants of a class/module
-  #
-  # ```ruby
-  # graph = AncestorGraph.new(env: env, ancestor_builder: ancestor_builder)
-  #
-  # graph.each_parent(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
-  # graph.each_ancestor(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
-  #
-  # graph.each_child(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
-  # graph.each_descendant(AncestorGraph::InstanceNode.new(type_name: TypeName.parse("::Object")))
-  # ```
-  #
-  # Note that the class works for class/module declarations.
-  # All of the *alias* classes/modules are ignored.
-  #
-  # * Alias classes/modules doesn't count as a parent nor child
-  # * Passing alias classes/modules to the method doesn't yield anything
-  #
-  class AncestorGraph
-    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
-
-    type node = InstanceNode | SingletonNode
-
-    attr_reader env: Environment
-    attr_reader ancestor_builder: DefinitionBuilder::AncestorBuilder
-    attr_reader parents: Hash[node, Set[node]]
-    attr_reader children: Hash[node, Set[node]]
-
-    def initialize: (env: Environment, ?ancestor_builder: DefinitionBuilder::AncestorBuilder) -> void
-
-    def each_parent: (node) { (node) -> void } -> void
-                   | (node) -> Enumerator[node, void]
-
-    def each_ancestor: (node, ?yielded: Set[node]) { (node) -> void } -> void
-                     | (node) -> Enumerator[node, void]
-
-    def each_child: (node) { (node) -> void } -> void
-                  | (node) -> Enumerator[node, void]
-
-    def each_descendant: (node, ?yielded: Set[node]) { (node) -> void } -> void
-                       | (node) -> Enumerator[node, void]
-
-    private
-
-    def build: () -> void
-
-    def build_ancestors: (node, DefinitionBuilder::AncestorBuilder::OneAncestors) -> void
-
-    def register: (parent: node, child: node) -> void
-  end
-end

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

@@ -1,102 +0,0 @@
-module RBS
-  module Annotate
-    class Annotations
-      type t = Skip | Source | Copy
-
-      def self.parse: (AST::Annotation) -> t?
-
-      attr_reader items: Array[t]
-
-      def initialize: (Array[t]) -> void
-
-      def skip?: () -> bool
-
-      def skip_all?: () -> bool
-
-      def test_path: (String path) -> bool
-
-      def test_path_string: (String pattern, String path) -> bool
-
-      def copy_annotation: -> Copy?
-
-      # Skip annotation allows skipping generating annotation of a subject.
-      #
-      #     %a{annotate:rdoc:skip}
-      #     %a{annotate:rdoc:skip:all}
-      #
-      class Skip
-        attr_reader annotation: AST::Annotation
-
-        attr_reader skip_children: bool
-
-        def initialize: (annotation: AST::Annotation, skip_children: bool) -> void
-
-        def hash: () -> Integer
-
-        def ==: (untyped) -> bool
-
-        alias eql? ==
-      end
-
-      # Source annotation allows where the documents are copied from.
-      #
-      # It allows specifying two directions: the source to read from, and the source to skip.
-      #
-      #     %a{annotate:rdoc:source:from=ext/pathname}
-      #     %a{annotate:rdoc:source:skip=ext/pathname/doc}
-      #
-      # When you want to specify several paths, repeat writing the Source annotation.
-      #
-      class Source
-        attr_reader annotation: AST::Annotation
-
-        attr_reader include_source: String?
-        attr_reader skip_source: String?
-
-        def initialize: (annotation: AST::Annotation, include: String) -> void
-                      | (annotation: AST::Annotation, skip: String) -> void
-
-        def hash: () -> Integer
-
-        def ==: (untyped) -> bool
-
-        alias eql? ==
-      end
-
-      # Copy annotation allows copying the doc from another subject.
-      # This helps working with incorrect RDoc annotations.
-      #
-      #     %a{annotate:rdoc:copy:Bar#baz}
-      #     %a{annotate:rdoc:copy:Bar.baz}
-      #     %a{annotate:rdoc:copy:Bar::Baz}
-      #
-      class Copy
-        attr_reader annotation: AST::Annotation
-
-        attr_reader source: String
-
-        def initialize: (annotation: AST::Annotation, source: String) -> void
-
-        # Returns a tuple of:
-        #
-        # - Type name
-        # - A pair of:
-        #   - Boolean which holds if it is singleton
-        #   - Name of method
-        def partition: () -> [TypeName, [bool, Symbol]?]
-
-        def type_name: () -> TypeName
-
-        def method_name: () -> Symbol?
-
-        def singleton?: () -> bool
-
-        def hash: () -> Integer
-
-        def ==: (untyped) -> bool
-
-        alias eql? ==
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-module RBS
-  module Annotate
-    class Formatter
-      attr_reader buffer: String
-
-      @pending_separator: String?
-
-      def initialize: () -> void
-
-      def <<: (String | RDoc::Markup::Document | nil) -> self
-
-      def margin: (?separator: String) -> self
-
-      def empty?: () -> bool
-
-      def format: (newline_at_end: bool) -> String
-
-      def self.translate: (RDoc::Markup::Document) -> String?
-
-      def self.each_part: (RDoc::Markup::Document | RDoc::Comment | String) { (RDoc::Markup::Document) -> void } -> void
-                        | (RDoc::Markup::Document | RDoc::Comment | String) -> Enumerator[RDoc::Markup::Document, void]
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-module RBS
-  module Annotate
-    class RDocAnnotator
-      attr_reader source: RDocSource
-
-      attr_accessor include_arg_lists: bool
-      attr_accessor include_filename: bool
-
-      def initialize: (source: RDocSource) -> void
-
-      def annotate_file: (Pathname, preserve: bool) -> void
-
-      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
-
-      interface _PathTester
-        def test_path: (String) -> bool
-      end
-
-      interface _WithRDocComment
-        def comment: () -> (RDoc::Markup::Document | RDoc::Comment | String)
-      end
-
-      def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void
-                   | (Array[Object & _WithRDocComment], tester: _PathTester) -> Enumerator[[RDoc::Markup::Document, Object & _WithRDocComment], void]
-
-      def join_docs: (Array[String?], ?separator: String) -> String?
-
-      def doc_for_class: (TypeName, tester: _PathTester) -> String?
-
-      # Returns the formatted document of given method.
-      #
-      # Expands attribute documents, or alias documents if needed.
-      #
-      def doc_for_method: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
-                        | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
-
-
-      def doc_for_method0: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
-                         | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
-
-      # Having `require: nil` means any attribute is okay.
-      # Having `require: "R"` means _read attr_ is required.
-      # Having `require: "W"` means write attr_ is required.
-      #
-      def doc_for_attribute: (TypeName, Symbol, singleton: bool, ?require: nil | "R" | "W", tester: _PathTester) -> String?
-
-      def doc_for_alias: (TypeName, name: Symbol, singleton: bool, tester: _PathTester) -> String?
-
-      def doc_for_constant: (TypeName, tester: _PathTester) -> String?
-
-      def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
-
-      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
-
-      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
-
-      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
-
-      def annotate_alias: (TypeName, AST::Members::Alias) -> void
-
-      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
-
-      def annotations: (_Annotated) -> Annotations
-
-      interface _Annotated
-        def annotations: -> Array[AST::Annotation]
-      end
-
-      # - If a string is given as `comment`, the content is attached to the object as a comment.
-      # - If empty string is given as `comment`, it deletes the original comment.
-      # - If `nil` is given as `comment`, it keeps the original comment.
-      #
-      def replace_comment: (Object & _Commented, String? comment) -> void
-
-      interface _Commented
-        def comment: () -> AST::Comment?
-      end
-
-      def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-module RBS
-  module Annotate
-    class RDocSource
-      attr_accessor with_system_dir: bool
-      attr_accessor with_gems_dir: bool
-      attr_accessor with_site_dir: bool
-      attr_accessor with_home_dir: bool
-
-      attr_reader extra_dirs: Array[Pathname]
-
-      attr_reader stores: Array[RDoc::Store]
-
-      def initialize: () -> void
-
-      def load: () -> void
-
-      # Extract documents from `CodeObject`s
-      def docs: () { () -> Array[RDoc::CodeObject]? } -> Array[RDoc::Markup::Document]?
-
-      def find_class: (TypeName) -> Array[RDoc::ClassModule]?
-
-      def find_const: (TypeName) -> Array[RDoc::Constant]?
-
-      def find_method: (TypeName, instance_method: Symbol) -> Array[RDoc::AnyMethod]?
-                     | (TypeName, singleton_method: Symbol) -> Array[RDoc::AnyMethod]?
-
-      def find_attribute: (TypeName, Symbol, singleton: bool) -> Array[RDoc::Attr]?
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module RBS
-  module AST
-    # RBS allows writing annotations of declarations and members.
-    #
-    # ```rbs
-    # %a{annotation_here}
-    # class Hello
-    #   %a{rbs:test:skip}
-    #   def foo: () -> void
-    # end
-    # ```
-    class Annotation
-      attr_reader string: String
-      attr_reader location: Location[untyped, untyped]?
-
-      def initialize: (string: String, location: Location[untyped, untyped]?) -> void
-
-      def ==: (untyped other) -> bool
-
-      alias eql? ==
-
-      def hash: () -> Integer
-
-      include _ToJson
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-module RBS
-  class Buffer
-    # Location in a buffer.
-    # A pair of line number (1 origin) and column number (0 origin).
-    #
-    type loc = [Integer, Integer]
-
-    # Name to identify Buffer.
-    attr_reader name: untyped
-
-    # The content of the buffer.
-    attr_reader content: String
-
-    @lines: Array[String]
-
-    @ranges: Array[Range[Integer]]
-
-    def initialize: (name: untyped name, content: String content) -> void
-
-    def lines: () -> Array[String]
-
-    def ranges: () -> Array[Range[Integer]]
-
-    # Translate position to location.
-    def pos_to_loc: (Integer pos) -> loc
-
-    # Translate location to position.
-    def loc_to_pos: (loc loc) -> Integer
-
-    def last_position: () -> Integer
-  end
-end

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

@@ -1,44 +0,0 @@
-module RBS
-  module BuiltinNames
-    class Name
-      attr_reader name: TypeName
-
-      @singleton_type: Types::t?
-
-      def initialize: (name: TypeName) -> void
-
-      def to_s: () -> String
-
-      def instance_type: (*Types::t) -> Types::ClassInstance
-
-      def instance_type?: (Types::t) -> bool
-
-      def singleton_type: () -> Types::ClassSingleton
-
-      def singleton_type?: (Types::t) -> bool
-
-      def self.define: (Symbol, ?namespace: Namespace) -> instance
-    end
-
-    BasicObject: Name
-    Object: Name
-    Kernel: Name
-    String: Name
-    Comparable: Name
-    Enumerable: Name
-    Class: Name
-    Module: Name
-    Array: Name
-    Hash: Name
-    Range: Name
-    Enumerator: Name
-    Set: Name
-    Symbol: Name
-    Integer: Name
-    Float: Name
-    Regexp: Name
-    TrueClass: Name
-    FalseClass: Name
-    Numeric: Name
-  end
-end

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

@@ -1,15 +0,0 @@
-module RBS
-  class CLI
-    class ColoredIO
-      attr_reader stdout: CLI::_IO
-      def initialize: (stdout: CLI::_IO) -> void
-      def puts_green: (String) -> void
-      def puts_red: (String) -> void
-      def puts: (?String) -> void
-
-      private def can_display_colors?: () -> bool
-      private def are_colors_supported?: () -> bool
-      private def are_colors_disabled?: () -> bool
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module RBS
-  class CLI
-    class Diff
-      @format: String
-      @stdout: _IO
-      @stderr: _IO
-      @diff: RBS::Diff
-
-      def initialize: (
-        argv: Array[String],
-        library_options: RBS::CLI::LibraryOptions,
-        ?stdout: _IO,
-        ?stderr: _IO,
-      ) -> void
-
-      def run: () -> void
-      def run_diff: () -> void
-      def run_markdown: () -> void
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-module RBS
-  class CLI
-    class Validate
-      class Errors
-        @limit: Integer?
-        @exit_error: boolish
-        @has_syntax_error: bool
-        @errors: Array[BaseError]
-
-        def initialize: (limit: Integer?, exit_error: boolish) -> void
-
-        def add: (BaseError) -> void
-
-        def finish: () -> void
-
-        private
-
-        def build_message: (BaseError) -> String
-      end
-
-      @env: Environment
-      @builder: RBS::DefinitionBuilder
-      @validator: RBS::Validator
-      @errors: Errors
-
-      def initialize: (args: Array[String], options: LibraryOptions) -> void
-
-      def run: () -> void
-
-      private
-
-      def validate_class_module_definition: () -> void
-      def validate_class_module_alias_definition: () -> void
-      def validate_interface: () -> void
-      def validate_constant: () -> void
-      def validate_global: () -> void
-      def validate_type_alias: () -> void
-      def no_self_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
-      def no_classish_type_validator: (::RBS::Types::t | ::RBS::MethodType type) -> void
-      def void_type_context_validator: (::RBS::Types::t | ::RBS::MethodType type, ?bool allowed_here) -> void
-    end
-  end
-end