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

@@ -1,258 +0,0 @@
-module RBS
-  module AST
-    module Members
-      type t = MethodDefinition
-             | InstanceVariable | ClassInstanceVariable | ClassVariable
-             | Include | Extend | Prepend
-             | AttrReader | AttrWriter | AttrAccessor
-             | Public | Private
-             | Alias
-
-      # Base class for members.
-      class Base
-      end
-
-      type visibility = :public | :private
-
-      class MethodDefinition < Base
-        class Overload
-          attr_reader method_type: MethodType
-
-          attr_reader annotations: Array[Annotation]
-
-          def initialize: (method_type: MethodType, annotations: Array[Annotation]) -> void
-
-          def ==: (untyped) -> bool
-
-          def hash: () -> Integer
-
-          alias eql? ==
-
-          def update: (?annotations: Array[Annotation], ?method_type: MethodType) -> Overload
-
-          def sub: (Substitution) -> Overload
-
-          include _ToJson
-        end
-
-        type kind = :instance | :singleton | :singleton_instance
-
-        # def foo: () -> void
-        # ^^^                    keyword
-        #     ^^^                name
-        #
-        # private def self.bar: () -> void | ...
-        # ^^^^^^^                                  visibility
-        #         ^^^                              keyword
-        #             ^^^^^                        kind
-        #                  ^^^                     name
-        #                                    ^^^   overloading
-        #
-        type loc = Location[:keyword | :name, :kind | :overloading | :visibility]
-
-        attr_reader name: Symbol
-        attr_reader kind: kind
-        attr_reader overloads: Array[Overload]
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-        attr_reader overloading: bool
-        attr_reader visibility: visibility?
-
-        def initialize: (name: Symbol, kind: kind, overloads: Array[Overload], annotations: Array[Annotation], location: loc?, comment: Comment?, overloading: bool, visibility: visibility?) -> void
-
-        include _HashEqual
-        include _ToJson
-
-        # Returns true if the `def` is to define instance method
-        def instance?: () -> bool
-
-        # Returns true if the `def` is to define singleton method
-        def singleton?: () -> bool
-
-        # Returns true if the `def` is overloading (== with `...`)
-        #
-        def overloading?: () -> bool
-
-        def update: (?name: Symbol, ?kind: kind, ?overloads: Array[Overload], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?overloading: bool, ?visibility: visibility?) -> MethodDefinition
-      end
-
-      module Var
-        # @foo: String
-        # ^^^^            name
-        #     ^           colon
-        #
-        # self.@all: Array[String]
-        # ^^^^^                        kind
-        #      ^^^^                    name
-        #          ^                   colon
-        #
-        type loc = Location[:name | :colon, :kind]
-
-        attr_reader name: Symbol
-        attr_reader type: Types::t
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (name: Symbol, type: Types::t, location: loc?, comment: Comment?) -> void
-
-        include _HashEqual
-      end
-
-      class InstanceVariable < Base
-        include Var
-        include _ToJson
-      end
-
-      class ClassInstanceVariable < Base
-        include Var
-        include _ToJson
-      end
-
-      class ClassVariable < Base
-        include Var
-        include _ToJson
-      end
-
-      module Mixin
-        # include Foo
-        # ^^^^^^^       keyword
-        #         ^^^   name
-        #
-        # include Array[String]
-        # ^^^^^^^                keyword
-        #         ^^^^^          name
-        #              ^^^^^^^^  args
-        #
-        type loc = Location[:name | :keyword, :args]
-
-        attr_reader name: TypeName
-        attr_reader args: Array[Types::t]
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, args: Array[Types::t], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
-
-        include _HashEqual
-      end
-
-      class Include < Base
-        include Mixin
-        include _ToJson
-      end
-
-      class Extend < Base
-        include Mixin
-        include _ToJson
-      end
-
-      class Prepend < Base
-        include Mixin
-        include _ToJson
-      end
-
-      module Attribute
-        type kind = :instance | :singleton
-
-        # attr_reader name: String
-        # ^^^^^^^^^^^                  keyword
-        #             ^^^^             name
-        #                 ^            colon
-        #
-        # public attr_accessor self.name (@foo) : String
-        # ^^^^^^                                           visibility
-        #        ^^^^^^^^^^^^^                             keyword
-        #                      ^^^^^                       kind
-        #                           ^^^^                   name
-        #                                ^^^^^^            ivar
-        #                                 ^^^^             ivar_name
-        #                                       ^          colon
-        #
-        type loc = Location[:keyword | :name | :colon, :kind | :ivar | :ivar_name | :visibility]
-
-        attr_reader name: Symbol
-        attr_reader type: Types::t
-        attr_reader kind: kind
-        attr_reader ivar_name: Symbol | false | nil
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-        attr_reader visibility: visibility?
-
-        def initialize: (name: Symbol, type: Types::t, ivar_name: Symbol | false | nil, kind: kind, annotations: Array[Annotation], location: loc?, comment: Comment?, ?visibility: visibility?) -> void
-
-        include _HashEqual
-
-        def update: (?name: Symbol, ?type: Types::t, ?ivar_name: Symbol | false | nil, ?kind: kind, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?, ?visibility: visibility?) -> instance
-      end
-
-      class AttrReader < Base
-        include Attribute
-        include _ToJson
-      end
-
-      class AttrAccessor < Base
-        include Attribute
-        include _ToJson
-      end
-
-      class AttrWriter < Base
-        include Attribute
-        include _ToJson
-      end
-
-      module LocationOnly
-        attr_reader location: Location[bot, bot]?
-
-        def initialize: (location: Location[bot, bot]?) -> void
-
-        include _HashEqual
-      end
-
-      class Public < Base
-        include LocationOnly
-        include _ToJson
-      end
-
-      class Private < Base
-        include LocationOnly
-        include _ToJson
-      end
-
-      class Alias < Base
-        type kind = :instance | :singleton
-
-        # alias foo bar
-        # ^^^^^           keyword
-        #       ^^^       new_name
-        #           ^^^   old_name
-        #
-        # alias self.foo self.bar
-        # ^^^^^                      keyword
-        #       ^^^^^                new_kind
-        #            ^^^             new_name
-        #                ^^^^^       old_kind
-        #                     ^^^    old_name
-        #
-        type loc = Location[:keyword | :new_name | :old_name, :new_kind | :old_kind]
-
-        attr_reader new_name: Symbol
-        attr_reader old_name: Symbol
-        attr_reader kind: kind
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (new_name: Symbol, old_name: Symbol, kind: kind, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
-
-        include _HashEqual
-        include _ToJson
-
-        def instance?: () -> bool
-
-        def singleton?: () -> bool
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-module RBS
-  class DefinitionBuilder
-    # MethodBuilder calculates the sequence of methods available on given type
-    #
-    # The sequence are sorted topologically.
-    #
-    class MethodBuilder
-      # Set of methods defined in a type.
-      #
-      class Methods
-        type instance_type = Types::ClassInstance | Types::ClassSingleton | Types::Interface
-
-        # Definition of a method in the type
-        #
-        # The Definition object allows invalid method definition so that more than one _original_ definitions may exist.
-        #
-        class Definition
-          type original = AST::Members::MethodDefinition | AST::Members::Alias | AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader
-
-          type accessibility = RBS::Definition::accessibility
-
-          attr_reader name: Symbol
-          attr_reader type: instance_type
-          attr_reader originals: Array[original]
-          attr_reader overloads: Array[AST::Members::MethodDefinition]
-          attr_reader accessibilities: Array[accessibility]
-
-          def initialize: (name: Symbol, type: instance_type, originals: Array[original], overloads: Array[AST::Members::MethodDefinition], accessibilities: Array[accessibility]) -> void
-
-          def original: () -> original?
-
-          def accessibility: () -> accessibility
-
-          def self.empty: (name: Symbol, type: instance_type) -> Definition
-        end
-
-        attr_reader type: instance_type
-        attr_reader methods: Hash[Symbol, Definition]
-
-        def initialize: (type: instance_type) -> void
-
-        def validate!: () -> self
-
-        def each: () { (Definition) -> void } -> void
-                | () -> Enumerator[Definition, void]
-
-        class Sorter
-          include TSort[Definition]
-
-          attr_reader methods: Hash[Symbol, Definition]
-
-          def initialize: (Hash[Symbol, Definition]) -> void
-
-          def tsort_each_node: { (Definition) -> void } -> void
-
-          def tsort_each_child: (Definition) { (Definition) -> void } -> void
-        end
-      end
-
-      attr_reader env: Environment
-      attr_reader instance_methods: Hash[TypeName, Methods]
-      attr_reader singleton_methods: Hash[TypeName, Methods]
-      attr_reader interface_methods: Hash[TypeName, Methods]
-
-      def initialize: (env: Environment) -> void
-
-      def build_instance: (TypeName) -> Methods
-
-      def build_singleton: (TypeName) -> Methods
-
-      def build_interface: (TypeName) -> Methods
-
-      def build_alias: (Methods, Methods::instance_type, member: AST::Members::Alias) -> void
-
-      def build_attribute: (Methods, Methods::instance_type, member: AST::Members::AttrAccessor | AST::Members::AttrReader | AST::Members::AttrWriter, accessibility: Definition::accessibility) -> void
-
-      def build_method: (Methods, Methods::instance_type, member: AST::Members::MethodDefinition, accessibility: Definition::accessibility) -> void
-
-      def each_member_with_accessibility: (Array[AST::Members::t | AST::Declarations::t], ?accessibility: Definition::accessibility) { (AST::Members::t | AST::Declarations::t, Definition::accessibility) -> void } -> void
-
-      def update: (env: Environment, except: _Each[TypeName]) -> MethodBuilder
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-module RBS
-  class MethodType
-    # () -> void
-    # ^^^^^^^^^^     type
-    #
-    # [A] () { () -> A } -> A
-    # ^^^                      type_params
-    #     ^^^^^^^^^^^^^^^^^^^  type
-    #
-    type def_loc = Location[:type, :type_params]
-
-    type attr_loc = AST::Members::Attribute::loc
-
-    type loc = def_loc | attr_loc
-
-    attr_reader type_params: Array[AST::TypeParam]
-    attr_reader type: Types::function
-    attr_reader block: Types::Block?
-    attr_reader location: loc?
-
-    def initialize: (type_params: Array[AST::TypeParam], type: Types::function, block: Types::Block?, location: loc?) -> void
-
-    def ==: (untyped other) -> bool
-
-    include _ToJson
-
-    # Substitute type variables to some types.
-    # Takes care of type parameter bounds.
-    #
-    def sub: (Substitution) -> MethodType
-
-    def update: (?type_params: Array[AST::TypeParam], ?type: Types::function, ?block: Types::Block?, ?location: loc?) -> MethodType
-
-    def free_variables: (?Set[Symbol] set) -> Set[Symbol]
-
-    # Apply the mapping included in the MethodType.
-    #
-    # Note that type bound in generics parameter is not handled by this method.
-    # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
-    #
-    def map_type: () { (Types::t) -> Types::t } -> MethodType
-
-    def map_type_bound: () { (Types::t) -> Types::t } -> MethodType
-
-    def each_type: () { (Types::t) -> void } -> void
-                 | () -> Enumerator[Types::t, void]
-
-    def to_s: () -> String
-
-    def type_param_names: () -> Array[Symbol]
-
-    def has_self_type?: () -> bool
-
-    def has_classish_type?: () -> bool
-
-    def with_nonreturn_void?: () -> bool
-  end
-end

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

@@ -1,146 +0,0 @@
-module RBS
-  # Namespace instance represents a _prefix of module names_.
-  #
-  # ```
-  # vvvvvvvvvvvvvv  TypeName
-  # RBS::Namespace
-  # ^^^^^           Namespace
-  #
-  # vvvvvvvvvv    TypeName
-  # RBS::Types
-  # ^^^^^         Namespace
-  #
-  # vvvvvvvvvvvvvvvvv    TypeName
-  # RBS::Types::Union
-  # ^^^^^^^^^^^^         Namespace
-  # ```
-  #
-  # Note that `Namespace` is an RBS specific concept and there is no corresponding concept in Ruby.
-  #
-  # There are _absolute_ and _relative_ namespaces.
-  #
-  # ```
-  # Namespace(::RBS::)         # Absolute namespace
-  # Namespace(  RBS::)         # Relative namespace
-  # ```
-  #
-  # It also defines two special namespaces.
-  #
-  # ```
-  # ::              # _Root_ namespace
-  #                 # _Empty_ namespace
-  # ```
-  #
-  class Namespace
-    attr_reader path: Array[Symbol]
-
-    def initialize: (path: Array[Symbol], absolute: boolish) -> void
-
-    @absolute: bool
-
-    @parent: Namespace?
-
-    self.@root: Namespace?
-
-    self.@empty: Namespace?
-
-    # Returns new _empty_ namespace.
-    def self.empty: () -> Namespace
-
-    # Returns new _root_ namespace.
-    def self.root: () -> Namespace
-
-    # Concat two namespaces.
-    #
-    # ```rb
-    # Namespace("Foo::") + Namespace("Bar::")   # => Foo::Bar::
-    # Namespace("::Foo::") + Namespace("Bar::") # => ::Foo::Bar::
-    # ```
-    #
-    # If `other` is an absolute namespace, it returns `other`.
-    #
-    # ```rb
-    # Namespace("Foo::") + Namespace("::Bar::")  # =>  ::Bar::
-    # ```
-    def +: (Namespace other) -> Namespace
-
-    # Add one path component to self.
-    #
-    # ```rb
-    # Namespace("Foo::").append(:Bar) # => Namespace("Foo::Bar::")
-    # ```
-    def append: (Symbol component) -> Namespace
-
-    # Returns parent namespace.
-    # Raises error there is no parent namespace.
-    #
-    # ```rb
-    # Namespace("::A").parent    # => Namespace("::")
-    # Namespace("::").parent     # raises error
-    # Namespace("A::B").parent   # => Namespace("A")
-    # ```
-    def parent: () -> Namespace
-
-    # Returns true if self is absolute namespace.
-    def absolute?: () -> bool
-
-    # Returns true if self is relative namespace.
-    def relative?: () -> bool
-
-    # Returns absolute namespace.
-    #
-    # ```rb
-    # Namespace("A").absolute!      # => Namespace("::A")
-    # Namespace("::A").absolute!    # => Namespace("::A")
-    # ```
-    def absolute!: () -> Namespace
-
-    # Returns _relative_ namespace.
-    #
-    def relative!: () -> Namespace
-
-    def empty?: () -> bool
-
-    # Equality is defined by its structure.
-    #
-    def ==: (untyped other) -> bool
-
-    alias eql? ==
-
-    # Hash is defined based on its structure.
-    #
-    def hash: () -> Integer
-
-    # Returns a pair of parent namespace and a symbol of last component.
-    #
-    # ```rb
-    # Namespace("::A::B::C").split    # => [Namespace("::A::B::"), :C]
-    # ```
-    def split: () -> [Namespace, Symbol]?
-
-    def to_s: () -> String
-
-    # Construct a type name which points to the same name type.
-    #
-    def to_type_name: () -> TypeName
-
-    def self.parse: (String string) -> Namespace
-
-    # Iterate over Namespace for each element in ascending order.
-    #
-    # ```rb
-    # Namespace.parse("::A::B::C").ascend {|ns| p ns }
-    #   # => ::A::B::C
-    #   # => ::A::B
-    #   # => ::A
-    #   # => ::(root)
-    # ```
-    def ascend: () { (Namespace) -> void } -> void
-              | () -> Enumerator[Namespace, void]
-  end
-end
-
-module Kernel
-  # Deprecated: Use `RBS::Namespace.parse` instead
-  %a{steep:deprecated} def Namespace: (String) -> RBS::Namespace
-end

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

@@ -1,96 +0,0 @@
-module RBS
-  class Parser
-    # Result of `Parser.lex`
-    class LexResult
-      attr_reader buffer: Buffer
-      attr_reader value: Array[Token]
-
-      def initialize: (buffer: Buffer, value: Array[Token]) -> void
-    end
-
-    # Represents a token per result of `Parser.lex`.
-    class Token
-      attr_reader type: Symbol
-      attr_reader location: Location[untyped, untyped]
-
-      def initialize: (type: Symbol, location: Location[untyped, untyped]) -> void
-      def value: () -> String
-      def comment?: () -> bool
-    end
-
-    # Parse a method type and return it
-    #
-    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
-    #
-    # ```ruby
-    # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
-    # RBS::Parser.parse_method_type("() -> void", range: 0...)                   # => `() -> void`
-    # RBS::Parser.parse_method_type("() -> void () -> String", range: 11...)     # => `() -> String`
-    # RBS::Parser.parse_method_type("() -> void () -> String", range: 23...)     # => nil
-    # ```
-    #
-    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
-    # (Defaults to `false`.)
-    #
-    # ```ruby
-    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: false)    # => `() -> void`
-    # RBS::Parser.parse_method_type("() -> void () -> String", require_eof: true)     # => Raises an error
-    #
-    # RBS::Parser.parse_method_type("", require_eof: true)                            # => nil
-    # ```
-    #
-    def self.parse_method_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> MethodType?
-
-    # Parse a type and return it
-    #
-    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
-    #
-    # ```ruby
-    # RBS::Parser.parse_type("String")                          # => `String`
-    # RBS::Parser.parse_type("String", range: 0...)             # => `String`
-    # RBS::Parser.parse_type("String Integer", pos: 7...)       # => `Integer`
-    # RBS::Parser.parse_type("String Integer", pos: 14...)      # => nil
-    # ```
-    #
-    # When `require_eof` is `true`, an error is raised if more tokens are left in the input.
-    # (Defaults to `false`.)
-    #
-    # ```ruby
-    # RBS::Parser.parse_type("String untyped", require_eof: false)    # => `String`
-    # RBS::Parser.parse_type("String untyped", require_eof: true)     # => Raises an error
-    #
-    # RBS::Parser.parse_type("", require_eof: true)                   # => nil
-    # ```
-    #
-    def self.parse_type: (Buffer | String, ?range: Range[Integer?], ?variables: Array[Symbol], ?require_eof: bool) -> Types::t?
-
-    # Parse whole RBS file and return an array of declarations
-    #
-    def self.parse_signature: (Buffer | String) -> [Buffer, Array[AST::Directives::t], Array[AST::Declarations::t]]
-
-    # Parse whole RBS file and return result.
-    #
-    # ```ruby
-    # RBS::Parser.lex("# Comment\nmodule A\nend\n").value.map(&:type)
-    # # => [:tLINECOMMENT, :kMODULE, :tUIDENT, :kEND, :pEOF]
-    # ```
-    def self.lex: (Buffer | String) -> LexResult
-
-    KEYWORDS: Hash[String, bot]
-
-    private
-
-    def self.buffer: (String | Buffer source) -> Buffer
-
-    def self._parse_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> Types::t?
-
-    def self._parse_method_type: (Buffer, Integer start_pos, Integer end_pos, Array[Symbol] variables, bool require_eof) -> MethodType?
-
-    def self._parse_signature: (Buffer, Integer end_pos) -> [Array[AST::Directives::t], Array[AST::Declarations::t]]
-
-    def self._lex: (Buffer, Integer end_pos) -> Array[[Symbol, Location[untyped, untyped]]]
-
-    class LocatedValue
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module RBS
-  module Prototype
-    module Helpers
-      type node = RubyVM::AbstractSyntaxTree::Node
-
-      def block_from_body: (node) -> Types::Block?
-
-      def each_node: (Array[untyped] nodes) { (node) -> void } -> void
-
-      def each_child: (node) { (node child) -> void } -> void
-
-      def any_node?: (node, ?nodes: Array[node]) { (node) -> bool } -> Array[node]?
-
-      def keyword_hash?: (node) -> bool
-
-      # Returns a symbol if the node is a symbol literal node
-      # 
-      def symbol_literal_node?: (node) -> Symbol?
-
-      def args_from_node: (node?) -> Array[untyped]
-
-      def untyped: () -> Types::Bases::Any
-
-      @untyped: Types::Bases::Any
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module RBS
-  module Prototype
-    class NodeUsage
-      include Helpers
-      
-      type node = RubyVM::AbstractSyntaxTree::Node
-
-      attr_reader node: node
-
-      attr_reader conditional_nodes: Set[node]
-
-      def initialize: (node) -> void
-
-      def calculate: (node, conditional: bool) -> void
-
-      def each_conditional_node: () { (node) -> void } -> void
-                               | () -> Enumerator[node, void]
-    end
-  end
-end