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

@@ -1,38 +0,0 @@
-module Bundler
-  class LockfileParser
-    def initialize: (String) -> void
-
-    def specs: () -> Array[LazySpecification]
-  end
-
-  class LazySpecification
-    def name: () -> String
-
-    def version: () -> String
-
-    def dependencies: () -> Array[Gem::Dependency]
-  end
-
-  class Dependency < Gem::Dependency
-    attr_reader autorequire: Array[String]?
-
-    attr_reader source: untyped
-  end
-
-  class Definition
-    def lockfile: () -> Pathname
-
-    def locked_gems: () -> LockfileParser
-
-    def dependencies: () -> Array[Dependency]
-  end
-
-  def self.default_lockfile: () -> Pathname
-
-  def self.definition: () -> Definition
-
-  module Source
-    class Gemspec
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module Enumerable[unchecked out Elem] : _Each[Elem]
-  def each_slice: (2) { ([Elem, Elem]) -> void } -> void
-                | (2) -> Enumerator[[Elem, Elem], void]
-                | ...
-end

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

@@ -1,19 +0,0 @@
-module Gem
-  class Specification
-    attr_reader version (): Version
-
-    attr_reader gem_dir (): String
-
-    def self.find_by_name: (String name, *String requirements) -> instance
-
-    def dependencies: () -> Array[Dependency]
-  end
-
-  class Dependency
-    def name: () -> String
-  end
-
-  module ::Kernel
-    def self?.gem: (String, *String) -> void
-  end
-end

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

@@ -1,41 +0,0 @@
-module RBS
-  class Sorter
-    include RBS::AST
-
-    type member = AST::Declarations::Class::member
-                | AST::Declarations::Module::member
-                | AST::Declarations::Interface::member
-
-    attr_reader path: Pathname
-
-    attr_reader stdout: IO
-
-    def initialize: (Pathname path, ?stdout: IO) -> void
-
-    def run: () -> void
-
-    type partitioned = {
-      type_alias_decls: Array[AST::Declarations::TypeAlias],
-      constant_decls: Array[AST::Declarations::Constant],
-      class_decls: Array[AST::Declarations::Class | AST::Declarations::Module | AST::Declarations::Interface],
-      mixin_includes: Array[AST::Members::Include],
-      mixin_prepends: Array[AST::Members::Prepend],
-      mixin_extends: Array[AST::Members::Extend],
-      class_variables: Array[AST::Members::ClassVariable],
-      class_instance_variables: Array[AST::Members::ClassInstanceVariable],
-      instance_variables: Array[AST::Members::InstanceVariable],
-      singleton_attributes: Array[AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader],
-      instance_attributes: Array[AST::Members::AttrAccessor | AST::Members::AttrWriter | AST::Members::AttrReader],
-      module_functions: Array[AST::Members::MethodDefinition],
-      singleton_new_methods: Array[AST::Members::MethodDefinition],
-      public_singleton_methods: Array[AST::Members::MethodDefinition | AST::Members::Alias],
-      private_singleton_methods: Array[AST::Members::MethodDefinition],
-      instance_initialize_methods: Array[AST::Members::MethodDefinition],
-      public_instance_methods: Array[AST::Members::MethodDefinition | AST::Members::Alias],
-      private_instance_methods: Array[AST::Members::MethodDefinition],
-      other_decls: Array[member]
-    }
-
-    def sort_decl: (member decl) -> member
-  end
-end

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

@@ -1,48 +0,0 @@
-module RBS
-  # Substitution from type variables to types.
-  #
-  # The substitution construction is in _destructive_ manner.
-  #
-  #    sub = Substitution.new
-  #    sub.add(from: :A, to: type1)
-  #    sub.add(from: :B, to: type2)
-  #    sub.instance_type = type3
-  #
-  class Substitution
-    # A hash containing mapping from type variable name to type.
-    attr_reader mapping: Hash[Symbol, Types::t]
-
-    # The result of applying this substitution to `instance` type.
-    # `nil` maps to `instance` type itself.
-    attr_accessor instance_type: Types::t?
-
-    def initialize: () -> void
-
-    # Add mapping to this substitution.
-    # Overwrites the previous mapping if same `from` is given.
-    def add: (from: Symbol, to: Types::t) -> void
-
-    # Utility method to construct a substitution.
-    # Raises an error when `variables.size != types.size`.
-    # `instance_type` defaults to `nil`.
-    #
-    # Yields types in `types` and the block value is used if block is given.
-    #
-    def self.build: (Array[Symbol] variables, Array[Types::t] types, ?instance_type: Types::t?) ?{ (Types::t) -> Types::t } -> instance
-
-    # Applies the substitution to given type.
-    def apply: (Types::t) -> Types::t
-
-    # Returns a substitution without variables given in `vars`.
-    def without: (*Symbol vars) -> Substitution
-
-    # Returns true if given substitution is identity.
-    def empty?: () -> bool
-
-    alias [] apply
-
-    # (s1 + s2)[t] == s2[s1[t]]
-    # 
-    def +: (Substitution) -> Substitution
-  end
-end

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

@@ -1,37 +0,0 @@
-module RBS
-  class Subtractor
-    type decl_with_members = AST::Declarations::Class | AST::Declarations::Module
-
-    @minuend: Array[AST::Declarations::t]
-    @subtrahend: Environment
-
-    def initialize: (Array[AST::Declarations::t] minuend, Environment subtrahend) -> void
-
-    def call: (?Array[AST::Declarations::t], ?context: Resolver::context) -> Array[AST::Declarations::t]
-
-    private def filter_members: (decl_with_members, context: Resolver::context) -> decl_with_members?
-
-    private def member_exist?: (TypeName owner, AST::Members::t, context: Resolver::context) -> boolish
-
-    private def method_exist?: (TypeName owner, Symbol method_name, AST::Members::MethodDefinition::kind) -> boolish
-
-    private def ivar_exist?: (TypeName owner, Symbol ivar_name, AST::Members::Attribute::kind) -> boolish
-
-    private def cvar_exist?: (TypeName owner, Symbol cvar_name) -> boolish
-
-    private def each_member: (TypeName owner) { (AST::Members::t | AST::Declarations::t) -> void } -> void
-                           | (TypeName owner) -> Enumerator[(AST::Members::t | AST::Declarations::t), void]
-
-    private def mixin_exist?: (TypeName owner, AST::Members::Include | AST::Members::Extend | AST::Members::Prepend, context: Resolver::context) -> boolish
-
-    private def filter_redundunt_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
-
-    private def access_modifier?: (AST::Declarations::t | AST::Members::t?) -> bool
-
-    private def update_decl: (decl_with_members, members: Array[AST::Declarations::t | AST::Members::t]) -> decl_with_members
-
-    private def absolute_typename: (TypeName, context: Resolver::context) -> TypeName
-
-    private def typename_candidates: (TypeName, context: Resolver::context) -> Array[TypeName]
-  end
-end

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

@@ -1,52 +0,0 @@
-module RBS
-  module Test
-    module Errors
-      type t = ArgumentTypeError | BlockArgumentError | ArgumentError | BlockArgumentError | ReturnTypeError | BlockReturnTypeError
-             | UnexpectedBlockError | MissingBlockError | UnresolvedOverloadingError
-
-      # Type of a argument value given to a method call is not compatible with the type from method type
-      class ArgumentTypeError
-      end
-
-      # Type of a argument value given to a block yield is not compatible with the type from method type
-      class BlockArgumentTypeError
-      end
-
-      # Incompatible number of args/keyword args is given to a method call
-      class ArgumentError
-      end
-
-      # Incompatible number of args is given to a block yield
-      class BlockArgumentError
-      end
-
-      # Type of return value from a method call is incompatible
-      class ReturnTypeError
-      end
-
-      # Type of return value from a block yield is incompatible
-      class BlockReturnTypeError
-      end
-
-      # Unexpected block is given
-      class UnexpectedBlockError
-      end
-
-      # Required block is missing
-      class MissingBlockError
-      end
-
-      # Any other error
-      class UnresolvedOverloadingError
-      end
-
-      def self.format_param: (Types::Function::Param) -> String
-
-      RESPOND_TO: UnboundMethod
-
-      def self.inspect_: (untyped) -> String
-
-      def self.to_string: (t) -> String
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-module RBS
-  module Test
-    module Guaranteed
-      module Inspect
-        def self?.guaranteed_inspect: (untyped) -> String
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module RBS
-  module Test
-    class TypeCheck
-      def initialize: (self_class: Module, builder: DefinitionBuilder, sample_size: Integer, unchecked_classes: Array[Module], instance_class: Module, class_class: Module) -> void
-
-      # Confirm if given `CallTrace` is compatible with `MethodType`
-      #
-      # Returns an array with detected errors.
-      #
-      def method_call: (Symbol, MethodType, CallTrace, errors: Array[Errors::t]) -> Array[Errors::t]
-
-      # Test if given `value` is compatible to type
-      #
-      # Returns `true` if the value has the type.
-      # 
-      def value: (untyped value, Types::t) -> bool
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-module RBS
-  module Test
-    # Object#class
-    CLASS: UnboundMethod
-
-    # Module#define_method
-    DEFINE_METHOD: UnboundMethod
-
-    # Kernel#inspect
-    INSPECT: UnboundMethod
-
-    # BasicObject#instance_eval
-    INSTANCE_EVAL: UnboundMethod
-
-    # BasicObject#instance_exec
-    INSTANCE_EXEC: UnboundMethod
-
-    # Kernel#is_a?
-    IS_AP: UnboundMethod
-
-    # Kernel#method
-    METHOD: UnboundMethod
-
-    # Kernel#methods
-    METHODS: UnboundMethod
-
-    # Kernel#pp
-    PP: UnboundMethod
-
-    # Kernel#singleton_class
-    SINGLETON_CLASS: UnboundMethod
-
-    # Kernel#respond_to?
-    RESPOND_TOP: UnboundMethod
-
-    class ArgumentsReturn
-      type exit_type = :return | :exception | :break
-
-      attr_reader arguments: Array[untyped]
-
-      attr_reader exit_value: untyped
-
-      attr_reader exit_type: exit_type
-
-      def initialize: (arguments: Array[untyped], exit_value: untyped, exit_type: exit_type) -> void
-
-      def self.return: (arguments: Array[untyped], value: untyped) -> ArgumentsReturn
-
-      def self.exception: (arguments: Array[untyped], exception: untyped) -> ArgumentsReturn
-
-      def self.break: (arguments: Array[untyped]) -> ArgumentsReturn
-
-      def return_value: () -> untyped
-
-      def exception: () -> untyped
-
-      def return?: () -> bool
-
-      def exception?: () -> bool
-
-      def break?: () -> bool
-    end
-
-    class CallTrace
-      attr_reader method_name: Symbol
-
-      attr_reader method_call: ArgumentsReturn
-
-      attr_reader block_calls: Array[ArgumentsReturn]
-
-      attr_reader block_given: bool
-
-      def initialize: (method_name: Symbol, method_call: ArgumentsReturn, block_calls: Array[ArgumentsReturn], block_given: bool) -> void
-    end
-
-    attr_accessor self.suffix: String
-
-    def self.reset_suffix: () -> String
-
-    def self.call: (untyped receiver, UnboundMethod, *untyped) ?{ () -> void } -> void
-  end
-end

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

@@ -1,53 +0,0 @@
-module RBS
-  # TypeAliasDependency calculates the dependencies between type aliases
-  #
-  # The dependencies are normalized automatically.
-  #
-  class TypeAliasDependency
-    attr_reader env: Environment
-
-    # A hash table from type alias name to it's direct dependencies
-    #
-    # The source type name and dependencies are normalized.
-    #
-    attr_reader direct_dependencies: Hash[TypeName, Set[TypeName]]
-
-    # A hash table from type alias name to a hash name with keys of transitive dependencies
-    #
-    # The source type name and dependencies are normalized.
-    #
-    attr_reader dependencies: Hash[TypeName, Hash[TypeName, bool]]
-
-    def initialize: (env: Environment) -> void
-
-    # Returns `true` if given type alias is circular
-    #
-    # Normalized given type name automatically.
-    #
-    def circular_definition?: (TypeName alias_name) -> bool
-
-    # Returns the set of direct dependencies from the given type name
-    #
-    # Given type name will be normalized automatically.
-    # Returns normalized type names.
-    #
-    def direct_dependencies_of: (TypeName) -> Set[TypeName]
-
-    # Returns the set of dependencies from the given type name
-    #
-    # Given type name will be normalized automatically.
-    # Returns normalized type names.
-    #
-    def dependencies_of: (TypeName) -> Set[TypeName]
-
-    def build_dependencies: () -> void
-
-    def transitive_closure: () -> void
-
-    private
-
-    def direct_dependency: (Types::t `type`, ?Set[TypeName] result) -> Set[TypeName]
-
-    def dependency: (TypeName start, TypeName vertex, ?boolish nested) -> void
-  end
-end

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

@@ -1,98 +0,0 @@
-module RBS
-  # `TypeAliasRegularity` validates if a type alias is regular or not.
-  #
-  # Generic and recursive type alias cannot be polymorphic in their definitions.
-  #
-  # ```rbs
-  # type foo[T] = Integer
-  #             | foo[T]?     # Allowed. The type argument of `foo` doesn't change.
-  #
-  # type bar[T] = Integer
-  #             | foo[T]
-  #             | foo[Array[T]]  # Allowed. There are two type arguments `T` and `Array[T]` of `foo`, but it's not definition of `foo`.
-  #
-  # type baz[T] = Integer
-  #             | baz[Array[T]]  # Error. Recursive definition of `baz` has different type argument from the definition.
-  # ```
-  #
-  # The `#nonregular?` method can be used to test if given type name is regular or not.
-  #
-  # ```rb
-  # validator = RBS::TypeAliasRegularity.validate(env: env)
-  #
-  # validator.nonregular?(TypeName.parse("::foo"))    # => nil
-  # validator.nonregular?(TypeName.parse("::bar"))    # => nil
-  # validator.nonregular?(TypeName.parse("::baz"))    # => TypeAliasRegularity::Diagnostic
-  # ```
-  #
-  # A special case is when the type argument is `untyped`.
-  #
-  # ```rbs
-  # type foo[T] = Integer | foo[untyped]    # This is allowed.
-  # ```
-  #
-  class TypeAliasRegularity
-    attr_reader env: Environment
-
-    attr_reader builder: DefinitionBuilder
-
-    # Diagnostics of each type aliases.
-    # The type names are normalized.
-    #
-    attr_reader diagnostics: Hash[TypeName, Diagnostic]
-
-    # `Diagnostic` represents an non-regular type alias declaration error.
-    # It consists of the name of the alias type and a type on which the nonregularity is detected.
-    #
-    # ```rbs
-    # type t[T] = Integer | t[T?]
-    # ```
-    #
-    # The type `t` is nonregular because it contains `t[T?]` on it's right hand side.
-    #
-    # ```
-    # diagnostic = validator.nonregular?(TypeName.parse("::t"))
-    # diagnostic.type_name         # => TypeName.parse("::t")
-    # diagnostic.nonregular_type   # => t[T?]
-    # ```
-    #
-    class Diagnostic
-      attr_reader type_name: TypeName
-
-      attr_reader nonregular_type: Types::Alias
-
-      def initialize: (type_name: TypeName, nonregular_type: Types::Alias) -> void
-    end
-
-    # Returns new instance which already run `#validate`.
-    #
-    def self.validate: (env: Environment) -> TypeAliasRegularity
-
-    def initialize: (env: Environment) -> void
-
-    # Returns `Diagnostic` instance if the alias type is nonregular.
-    # Returns `nil` if the alias type is regular.
-    #
-    # Normalizes the given type name automatically.
-    #
-    def nonregular?: (TypeName) -> Diagnostic?
-
-    def validate: () -> void
-
-    private
-
-    def validate_alias_type: (Types::Alias, Set[TypeName], Hash[TypeName, Types::Alias]) -> void
-
-    # Returns alias type for given type name, if the alias is generic.
-    # Returns nil if the type alias is not generic.
-    #
-    def build_alias_type: (TypeName) -> Types::Alias?
-
-    def compatible_args?: (Array[Types::t], Array[Types::t]) -> boolish
-
-    def each_alias_type: (Types::t) { (Types::Alias) -> void } -> void
-
-    # Yields set of normalized type names
-    def each_mutual_alias_defs: () { (Set[TypeName]) -> void } -> void
-  end
-end

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

@@ -1,110 +0,0 @@
-module RBS
-  module AST
-    class TypeParam
-      # Key
-      # ^^^ name
-      #
-      # unchecked out Elem < _ToJson = untyped
-      # ^^^^^^^^^                                 unchecked
-      #           ^^^                             variance
-      #               ^^^^                        name
-      #                    ^^^^^^^^^              upper_bound
-      #                              ^^^^^^^^^    default
-      type loc = Location[:name, :variance | :unchecked | :upper_bound | :default]
-
-      type variance = :invariant | :covariant | :contravariant
-
-      type bound = Types::ClassInstance | Types::ClassSingleton | Types::Interface
-
-      attr_reader name: Symbol
-      attr_reader variance: variance
-      attr_reader location: loc?
-
-      %a{pure} def upper_bound: () -> bound?
-
-      attr_reader upper_bound_type: Types::t?
-
-      attr_reader default_type: Types::t?
-
-      def initialize: (name: Symbol, variance: variance, upper_bound: Types::t?, location: loc?, ?default_type: Types::t?) -> void
-
-      include _ToJson
-
-      def ==: (untyped) -> bool
-
-      def eql?: (untyped) -> bool
-
-      def hash: () -> Integer
-
-      @unchecked: bool
-
-      def unchecked!: (?boolish) -> self
-
-      def unchecked?: () -> bool
-
-      def map_type: () { (Types::t) -> Types::t } -> TypeParam
-
-      # Helper function to resolve _class instance types_ to _type variables_.
-      #
-      # We need this step because RBS language has an identical syntax for both unqualified class instance types and type variables.
-      # `String` may be an instance of `::String` class or type variable depending on the list of bound type variables.
-      #
-      # So, we need second pass to parse the following generics parameter declaration.
-      #
-      # ```rbs
-      # class Foo[X < _Each[Y], Y]
-      #                   # ^ We want this `Y` to be a type variable.
-      # end
-      # ```
-      #
-      def self.resolve_variables: (Array[TypeParam]) -> void
-
-      def self.subst_var: (Set[Symbol], Types::t) -> Types::t
-
-      # Rename type parameter name.
-      #
-      # The renaming cannot be done separately because a set of `TypeParam` decls may be mutual recursive.
-      #
-      # Example:
-      #
-      # * Renaming `A -> X, B -> Y`
-      # * Input `[A, B < _Pushable[A]]`
-      # * Result `[X, Y < _Pushable[X]]`
-      #
-      def self.rename: (Array[TypeParam], new_names: Array[Symbol]) -> Array[TypeParam]
-
-      def to_s: () -> String
-
-      # Validates TypeParams if it refers another optional type params
-      #
-      # * Returns array of TypeParam objects that refers other optional type params
-      # * Returns `nil` if all type params are valid
-      #
-      def self.validate: (Array[TypeParam]) -> Array[TypeParam]?
-
-      # Returns an application with respect to type params' default
-      #
-      def self.application: (Array[TypeParam], Array[Types::t]) -> Substitution?
-
-      # Returns an array of type args, that fills omitted types with the defaults
-      #
-      # ```rbs
-      # interface _Foo[T, S = untyped]
-      # end
-      # ```
-      #
-      # Normalizing type args with `_Foo` works as following:
-      #
-      # ```rbs
-      # _Foo[String]                   # => _Foo[String, untyped]
-      # _Foo[String, Integer]          # => _Foo[String, Integer]
-      # _Foo                           # => _Foo                            (Omitting missing args)
-      # _Foo[String, Integer, untyped] # => _Foo[String, Integer, untyped]  (Keeping extra args)
-      # ```
-      #
-      # Note that it allows invalid arities, returning the `args` immediately.
-      #
-      def self.normalize_args: (Array[TypeParam], Array[Types::t]) -> Array[Types::t]
-    end
-  end
-end