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

@@ -1,267 +0,0 @@
-module RBS
-  module AST
-    module Declarations
-      type t = Class | Module | Interface | Constant | Global | TypeAlias | ClassAlias | ModuleAlias
-
-      class Base
-      end
-
-      interface _WithMember
-        def members: () -> Array[untyped]
-      end
-
-      module NestedDeclarationHelper : _WithMember
-        def each_member: () { (Members::t) -> void } -> void
-                       | () -> Enumerator[Members::t, void]
-
-        def each_decl: () { (t) -> void } -> void
-                     | () -> Enumerator[t, void]
-      end
-
-      module MixinHelper : _WithMember
-        type mixin_member = Members::Include | Members::Extend | Members::Prepend
-
-        @mixins: Array[mixin_member]
-
-        def each_mixin: () { (mixin_member) -> void } -> void
-                      | () -> Enumerator[mixin_member, void]
-      end
-
-      class Class < Base
-        class Super
-          # String
-          # ^^^^^^  name
-          #
-          # Array[String]
-          # ^^^^^         name
-          #      ^^^^^^^^ args
-          #
-          type loc = Location[:name, :args]
-
-          attr_reader name: TypeName
-          attr_reader args: Array[Types::t]
-          attr_reader location: loc?
-
-          def initialize: (name: TypeName, args: Array[Types::t], location: loc?) -> void
-
-          include _HashEqual
-          include _ToJson
-        end
-
-        type member = Members::t | t
-
-        # class Foo end
-        # ^^^^^         keyword
-        #       ^^^     name
-        #           ^^^ end
-        #
-        # class Foo[A] < String end
-        # ^^^^^                     keyword
-        #       ^^^                 name
-        #          ^^^              type_params
-        #              ^            lt
-        #                       ^^^ end
-        #
-        type loc = Location[:keyword | :name | :end, :type_params | :lt]
-
-        include NestedDeclarationHelper
-        include MixinHelper
-
-        attr_reader name: TypeName
-        attr_reader type_params: Array[TypeParam]
-        attr_reader members: Array[member]
-        attr_reader super_class: Super?
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], super_class: Super?, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
-
-        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?super_class: Super?, ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Class
-
-        include _HashEqual
-        include _ToJson
-      end
-
-      class Module < Base
-        class Self
-          # _Each[String]
-          # ^^^^^         name
-          #      ^^^^^^^^ args
-          #
-          type loc = Location[:name, :args]
-
-          attr_reader name: TypeName
-          attr_reader args: Array[Types::t]
-          attr_reader location: loc?
-
-          def initialize: (name: TypeName, args: Array[Types::t], location: loc?) -> void
-
-          include _HashEqual
-          include _ToJson
-
-          def to_s: () -> String
-        end
-
-        type member = Members::t | t
-
-        # module Foo end
-        # ^^^^^^         keyword
-        #        ^^^     name
-        #            ^^^ end
-        #
-        # module Foo[A] : BasicObject end
-        # ^^^^^^                          keyword
-        #        ^^^                      name
-        #           ^^^                   type_params
-        #               ^                 colon
-        #                 ^^^^^^^^^^^     self_types
-        #                             ^^^ end
-        #
-        type loc = Location[:keyword | :name | :end, :type_params | :colon | :self_types]
-
-        include NestedDeclarationHelper
-        include MixinHelper
-
-        attr_reader name: TypeName
-        attr_reader type_params: Array[TypeParam]
-        attr_reader members: Array[member]
-        attr_reader location: loc?
-        attr_reader annotations: Array[Annotation]
-        attr_reader self_types: Array[Self]
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], location: loc?, annotations: Array[Annotation], self_types: Array[Self], comment: Comment?) -> void
-
-        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?location: loc?, ?annotations: Array[Annotation], ?self_types: Array[Self], ?comment: Comment?) -> Declarations::Module
-
-        include _HashEqual
-        include _ToJson
-      end
-
-      class Interface < Base
-        type member = Members::t
-
-        # interface _Foo end
-        # ^^^^^^^^^          keyword
-        #           ^^^^     name
-        #                ^^^ end
-        #
-        # interface _Bar[A, B] end
-        # ^^^^^^^^^                keyword
-        #           ^^^^           name
-        #               ^^^^^^     type_params
-        #                      ^^^ end
-        #
-        type loc = Location[:name | :keyword | :end, :type_params]
-
-        attr_reader name: TypeName
-        attr_reader type_params: Array[TypeParam]
-        attr_reader members: Array[member]
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type_params: Array[TypeParam], members: Array[member], annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
-
-        def update: (?name: TypeName, ?type_params: Array[TypeParam], ?members: Array[member], ?annotations: Array[Annotation], ?location: loc?, ?comment: Comment?) -> Declarations::Interface
-
-        include MixinHelper
-
-        include _HashEqual
-        include _ToJson
-      end
-
-      class TypeAlias < Base
-        # type loc[T] = Location[T, bot]
-        # ^^^^                            keyword
-        #      ^^^                        name
-        #         ^^^                     type_params
-        #             ^                      eq
-        #
-        type loc = Location[:keyword | :name | :eq, :type_params]
-
-        attr_reader name: TypeName
-        attr_reader type_params: Array[TypeParam]
-        attr_reader type: Types::t
-        attr_reader annotations: Array[Annotation]
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type_params: Array[TypeParam], type: Types::t, annotations: Array[Annotation], location: loc?, comment: Comment?) -> void
-
-        include _HashEqual
-        include _ToJson
-      end
-
-      class Constant < Base
-        # VERSION: String
-        # ^^^^^^^         name
-        #        ^        colon
-        #
-        type loc = Location[:name | :colon, bot]
-
-        attr_reader name: TypeName
-        attr_reader type: Types::t
-        attr_reader location: loc?
-        attr_reader comment: Comment?
-
-        def initialize: (name: TypeName, type: Types::t, location: loc?, comment: Comment?) -> void
-
-        include _HashEqual
-        include _ToJson
-      end
-
-      class Global < Base
-        # $SIZE: String
-        # ^^^^^         name
-        #      ^        colon
-        #
-        type loc = Location[:name | :colon, bot]
-
-        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
-        include _ToJson
-      end
-
-      class AliasDecl < Base
-        # module Foo = Bar
-        # ^^^^^^             keyword
-        #        ^^^         new_name
-        #            ^       eq
-        #              ^^^   old_name
-        #
-        # class Foo = Bar
-        # ^^^^^              keyword
-        #
-        type loc = Location[:keyword | :new_name | :eq | :old_name, bot]
-
-        attr_reader new_name: TypeName
-
-        attr_reader old_name: TypeName
-
-        attr_reader location: loc?
-
-        attr_reader comment: Comment?
-
-        def initialize: (new_name: TypeName, old_name: TypeName, location: loc?, comment: Comment?) -> void
-
-        include _HashEqual
-      end
-
-      class ClassAlias < AliasDecl
-        include _ToJson
-      end
-
-      class ModuleAlias < AliasDecl
-        include _ToJson
-      end
-    end
-  end
-end

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

@@ -1,173 +0,0 @@
-module RBS
-  class Definition
-    type accessibility = :public | :private
-
-    class Variable
-      attr_reader parent_variable: Variable?
-      attr_reader type: Types::t
-      attr_reader declared_in: TypeName
-
-      def initialize: (parent_variable: Variable?, type: Types::t, declared_in: TypeName) -> void
-
-      def sub: (Substitution) -> Variable
-    end
-
-    class Method
-      type method_member = AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrAccessor | AST::Members::AttrWriter
-
-      class TypeDef
-        attr_reader type: MethodType
-        attr_reader member: method_member
-        attr_reader defined_in: TypeName
-        attr_reader implemented_in: TypeName?
-
-        # Annotations given to `#member`
-        attr_reader member_annotations: Array[AST::Annotation]
-
-        # Annotations given to the overload associated to the method type
-        attr_reader overload_annotations: Array[AST::Annotation]
-
-        # Concatenation of `member_annotations` and `overload_annotations`
-        attr_reader annotations: Array[AST::Annotation]
-
-        def initialize: (type: MethodType, member: method_member, defined_in: TypeName, implemented_in: TypeName?, ?overload_annotations: Array[AST::Annotation]) -> void
-
-        def comment: () -> AST::Comment?
-
-        def update: (?type: MethodType, ?member: method_member, ?defined_in: TypeName, ?implemented_in: TypeName?) -> TypeDef
-
-        def overload?: () -> bool
-      end
-
-      attr_reader super_method: Method?
-      attr_reader defs: Array[TypeDef]
-      attr_reader accessibility: accessibility
-
-      attr_reader defined_in: TypeName?
-      attr_reader implemented_in: TypeName?
-      attr_reader method_types: Array[MethodType]
-      attr_reader comments: Array[AST::Comment]
-
-      attr_reader members: Array[method_member]
-      attr_reader alias_of: Method?
-
-      # Unused, always returns empty array
-      attr_reader extra_annotations: Array[AST::Annotation]
-
-      # Union of annotations given to `defs`, not contains annotations given to each overload
-      attr_reader annotations: Array[AST::Annotation]
-
-      # Note that the annotations given through `annotations:` keyword is ignored.
-      #
-      def initialize: (super_method: Method?,
-                       defs: Array[TypeDef],
-                       accessibility: accessibility,
-                       alias_of: Method?,
-                       ?annotations: Array[AST::Annotation]) -> void
-
-      def public?: () -> bool
-
-      def private?: () -> bool
-
-      # Substitutes type variables to some types.
-      # Takes care of type parameter bounds.
-      #
-      def sub: (Substitution) -> Method
-
-      # Applies the mapping from `Types::t` to `Types::t`.
-      #
-      # Note this method doesn't handle upper bound in type params.
-      # You may want to use `#map_type_bound` explicitly, or `#sub` for simple substitution.
-      #
-      def map_type: () { (Types::t) -> Types::t } -> Method
-
-      def map_type_bound: () { (Types::t) -> Types::t } -> Method
-
-      def map_method_type: () { (MethodType) -> MethodType } -> Method
-
-      def update: (
-        ?super_method: Method?,
-        ?defs: Array[TypeDef],
-        ?accessibility: accessibility,
-        ?alias_of: Method?,
-        ?annotations: Array[AST::Annotation]
-      ) -> Method
-    end
-
-    module Ancestor
-      type t = Instance | Singleton
-
-      class Instance
-        type source = :super     # Inheritance
-                    | nil        # Itself
-                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend  # AST
-                    | AST::Declarations::Module::Self
-
-        attr_reader name: TypeName
-        attr_reader args: Array[Types::t]
-        attr_reader source: source
-
-        def initialize: (name: TypeName, args: Array[Types::t], source: source) -> void
-      end
-
-      class Singleton
-        attr_reader name: TypeName
-
-        def initialize: (name: TypeName) -> void
-      end
-    end
-
-    class InstanceAncestors
-      attr_reader type_name: TypeName
-      attr_reader params: Array[Symbol]
-      attr_reader ancestors: Array[Ancestor::t]
-
-      def initialize: (type_name: TypeName, params: Array[Symbol], ancestors: Array[Ancestor::t]) -> void
-
-      def apply: (Array[Types::t], env: Environment, location: Location[untyped, untyped]?) -> Array[Ancestor::t]
-    end
-
-    class SingletonAncestors
-      attr_reader type_name: TypeName
-      attr_reader ancestors: Array[Ancestor::t]
-
-      def initialize: (type_name: TypeName, ancestors: Array[Ancestor::t]) -> void
-    end
-
-    type self_type = Types::ClassSingleton | Types::ClassInstance | Types::Interface
-    type definition_entry = Environment::ModuleEntry | Environment::ClassEntry | Environment::InterfaceEntry
-
-    attr_reader type_name: TypeName
-    attr_reader entry: definition_entry
-    attr_reader ancestors: InstanceAncestors | SingletonAncestors | nil
-    attr_reader self_type: self_type
-    attr_reader methods: Hash[Symbol, Method]
-    attr_reader instance_variables: Hash[Symbol, Variable]
-    attr_reader class_variables: Hash[Symbol, Variable]
-
-    def initialize: (type_name: TypeName, entry: definition_entry, self_type: self_type, ancestors: InstanceAncestors | SingletonAncestors | nil) -> void
-
-    def class?: () -> bool
-
-    def module?: () -> bool
-
-    def interface?: () -> bool
-
-    def class_type?: () -> bool
-
-    def instance_type?: () -> bool
-
-    def interface_type?: () -> bool
-
-    def type_params: () -> Array[Symbol]
-
-    def type_params_decl: () -> Array[AST::TypeParam]
-
-    def sub: (Substitution) -> Definition
-
-    def map_method_type: () { (MethodType) -> MethodType } -> Definition
-
-    def each_type: () { (Types::t) -> void } -> void
-                 | () -> Enumerator[Types::t, void]
-  end
-end

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

@@ -1,165 +0,0 @@
-module RBS
-  # DefinitionBuilder translates TypeName to Definition of the type
-  #
-  # It also provides semantic utilities that depends on Environment.
-  #
-  class DefinitionBuilder
-    attr_reader env: Environment
-    attr_reader ancestor_builder: AncestorBuilder
-    attr_reader method_builder: MethodBuilder
-
-    attr_reader instance_cache: Hash[TypeName, Definition | false | nil]
-    attr_reader singleton_cache: Hash[TypeName, Definition | false | nil]
-    attr_reader singleton0_cache: Hash[TypeName, Definition | false | nil]
-    attr_reader interface_cache: Hash[TypeName, Definition | false | nil]
-
-    def initialize: (env: Environment, ?ancestor_builder: AncestorBuilder?, ?method_builder: MethodBuilder?) -> void
-
-    # Returns a Definition of a interface
-    #
-    def build_interface: (TypeName) -> Definition
-
-    # Returns a Definition of an instance type
-    #
-    # If TypeName is a module and `no_self_types` is `true`, it won't have methods of _self type constraints_.
-    # This typically happens when definition is being calculated for mixin.
-    #
-    def build_instance: (TypeName) -> Definition
-
-    # Returns a Definition of a singleton type
-    def build_singleton: (TypeName) -> Definition
-
-    # Validates the given Namespace and its ancestor namespaces exists
-    #
-    # Raises NoTypeFoundError
-    #
-    def ensure_namespace!: (Namespace, location: Location[untyped, untyped]?) -> void
-
-    # Expand a type alias of given name without type arguments.
-    # Raises an error if the type alias requires arguments.
-    #
-    # Assume `type foo[T] = [T, T]`:
-    #
-    # ```
-    # expand_alias("::foo")   # => error
-    # ```
-    #
-    def expand_alias: (TypeName) -> Types::t
-
-    # Expand a type alias of given name with arguments of `untyped`.
-    #
-    # Assume `type foo[T] = [T, T]`:
-    #
-    # ```
-    # expand_alias1("::foo")   # => [untyped, untyped]
-    # ```
-    #
-    def expand_alias1: (TypeName) -> Types::t
-
-    # Expand a type alias of given name with `args`.
-    #
-    # Assume `type foo[T] = [T, T]`:
-    #
-    # ```
-    # expand_alias2("::foo", ["::Integer"])   # => [::Integer, ::Integer]
-    # ```
-    #
-    def expand_alias2: (TypeName, Array[Types::t] args) -> Types::t
-
-    # Validates presence of type names recursively
-    #
-    # Assumes the type names are already resolved.
-    # Raises NoTypeFoundError in case of failure.
-    #
-    # Normalizes type names in the given type automatically.
-    #
-    def validate_type_presence: (Types::t) -> void
-
-    # Validates presence of an absolute type name
-    #
-    # Raises NoTypeFoundError in case of error.
-    #
-    # Normalizes the given type name automatically.
-    #
-    def validate_type_name: (TypeName, Location[untyped, untyped]?) -> void
-
-    # Returns a new DefinitionBuilder with updated Environment, AncestorBuilder, and exceptions
-    #
-    def update: (env: Environment, ancestor_builder: AncestorBuilder, except: _Each[TypeName]) -> DefinitionBuilder
-
-    private
-
-    def validate_super_class!: (TypeName, Environment::ClassEntry) -> void
-
-    def build_singleton0: (TypeName) -> Definition
-
-    # Returns `interface_methods` from given array of interface ancestors
-    #
-    def interface_methods: (Array[Definition::Ancestor::Instance] interface_ancestors) -> interface_methods
-
-    def try_cache: (TypeName, cache: Hash[TypeName, Definition | false | nil]) { () -> Definition } -> Definition
-
-    def validate_params_with: (Array[AST::TypeParam], result: VarianceCalculator::Result) { (AST::TypeParam) -> void } -> void
-
-    def validate_type_params: (Definition, ancestors: AncestorBuilder::OneAncestors, methods: MethodBuilder::Methods) -> void
-
-    def source_location: (Definition::Ancestor::Instance::source, AST::Declarations::t) -> Location[untyped, untyped]?
-
-    def insert_variable: (TypeName, Hash[Symbol, Definition::Variable], name: Symbol, type: Types::t) -> void
-
-    # Add method definition to `methods`, which will be merged to `class_definition` after defining all methods at this *level* -- class, module, or interface
-    #
-    # `class_definition` is a definition of given type, but it has definitions of prior levels.
-    #
-    def define_method: (
-      Hash[Symbol, Definition::Method] methods,
-      Definition class_definition,
-      MethodBuilder::Methods::Definition method_definition,
-      Substitution subst,
-      Hash[Symbol, Definition::Method]? self_type_methods,
-      defined_in: TypeName,
-      ?implemented_in: TypeName?
-    ) -> void
-
-    # The `interface_methods` type describes the association between the interface name to its name and the *mixin* to a module
-    #
-    type interface_methods = Hash[
-      Definition::Ancestor::Instance,
-      [MethodBuilder::Methods, AST::Members::Include | AST::Members::Extend]
-    ]
-
-    # Add method definitions from `module_methods` to `definition`
-    #
-    # It also processes interface mixins, with duplication detection.
-    # It doesn't process module mixins.
-    #
-    def import_methods: (
-      Definition definition,
-      TypeName module_name,
-      MethodBuilder::Methods module_methods,
-      interface_methods interface_methods,
-      Substitution subst,
-      Hash[Symbol, Definition::Method]? self_type_methods,
-    ) -> void
-
-    # Updates `definition` with methods and variables of `type_name` that can be a module or a class
-    #
-    # It processes includes and prepends recursively.
-    #
-    def define_instance: (Definition definition, TypeName type_name, Substitution subst) -> void
-
-    # Updates `definition` with methods defined in an interface `type_name`
-    #
-    # It processes includes recursively
-    #
-    def define_interface: (Definition definition, TypeName type_name, Substitution subst) -> void
-
-    # Returns a substitution that corresponds to type application
-    #
-    # ```
-    # tapp_subst(`::Array`, [`::Integer`]) # => Substitution.build([:Elem], [`::Integer`])
-    # ```
-    #
-    def tapp_subst: (TypeName, Array[Types::t]) -> Substitution
-  end
-end

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

@@ -1,28 +0,0 @@
-module RBS
-  class Diff
-    @type_name: TypeName
-    @library_options: RBS::CLI::LibraryOptions
-    @after_path: Array[String]
-    @before_path: Array[String]
-    @detail: boolish
-
-    def initialize: (
-      type_name: TypeName,
-      library_options: RBS::CLI::LibraryOptions,
-      ?after_path: Array[String],
-      ?before_path: Array[String],
-      ?detail: boolish
-    ) -> void
-
-    def each_diff: () { (String before, String after) -> void } -> void
-
-    private def each_diff_by: (Symbol kind, Hash[::Symbol, Definition::Method] before_methods, Hash[::Symbol, Definition::Method] after_methods) { (String before, String after) -> void } -> void
-    private def build_methods: (Array[String] path) -> [ Hash[::Symbol, Definition::Method], Hash[::Symbol, Definition::Method] , Hash[Symbol, Constant]]
-    private def build_env: (Array[String] path) -> Environment
-    private def build_builder: (Environment env) -> DefinitionBuilder
-    private def definition_method_to_s: (Symbol key, Symbol kind, Definition::Method definition_method) -> String?
-    private def each_diff_methods: (Symbol kind, Hash[Symbol, Definition::Method], Hash[Symbol, Definition::Method]) { (String before, String after) -> void } -> void
-    private def each_diff_constants: (Hash[Symbol, Constant] before_constants, Hash[Symbol, Constant] after_constants) { (String before, String after) -> void } -> void
-    private def constant_to_s: (Constant?) -> String
-  end
-end

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

@@ -1,61 +0,0 @@
-module RBS
-  module AST
-    module Directives
-      type t = Use
-
-      class Base
-      end
-
-      # ```
-      # use Foo, Foo::Bar as FBar, Foo:Baz::*
-      # ```
-      #
-      class Use < Base
-        type clause = SingleClause | WildcardClause
-
-        class SingleClause
-          # Foo::Bar
-          # ^^^^^^^^       type_name
-          #
-          # Foo::Bar as X
-          #          ^^    keyword
-          #             ^  new_name
-          #
-          type loc = Location[:type_name, :keyword | :new_name]
-
-          attr_reader type_name: TypeName
-
-          attr_reader new_name: Symbol?
-
-          attr_reader location: loc?
-
-          def initialize: (type_name: TypeName, new_name: Symbol?, location: loc?) -> void
-        end
-
-        class WildcardClause
-          # Foo::Bar::*
-          # ^^^^^^^^^^    namespace
-          #           ^   star
-          #
-          type loc = Location[:namespace | :star, bot]
-
-          attr_reader namespace: Namespace
-
-          attr_reader location: loc?
-
-          def initialize: (namespace: Namespace, location: loc?) -> void
-        end
-
-        # use Foo
-        # ^^^       keyword
-        type loc = Location[:keyword, bot]
-
-        attr_reader clauses: Array[clause]
-
-        attr_reader location: loc?
-
-        def initialize: (clauses: Array[clause], location: loc?) -> void
-      end
-    end
-  end
-end