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

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

@@ -1,433 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module Test
-    class TypeCheck
-      attr_reader :self_class
-      attr_reader :builder
-      attr_reader :sample_size
-      attr_reader :unchecked_classes
-      attr_reader :instance_class
-      attr_reader :class_class
-
-      DEFAULT_SAMPLE_SIZE = 100
-
-      def initialize(self_class:, builder:, sample_size:, unchecked_classes:, instance_class: Object, class_class: Module)
-        @self_class = self_class
-        @instance_class = instance_class
-        @class_class = class_class
-        @builder = builder
-        @sample_size = sample_size
-        @unchecked_classes = unchecked_classes.uniq
-      end
-
-      def overloaded_call(method, method_name, call, errors:)
-        es = method.method_types.map do |method_type|
-          es = method_call(method_name, method_type, call, errors: [])
-
-          if es.empty?
-            return errors
-          else
-            es
-          end
-        end
-
-        if es.size == 1
-          errors.push(*es[0])
-        else
-          error = Errors::UnresolvedOverloadingError.new(
-            klass: self_class,
-            method_name: method_name,
-            method_types: method.method_types
-          )
-          RBS.logger.warn do
-            tag = Errors.method_tag(error)
-            message = +"#{tag} UnresolvedOverloadingError "
-            message << method.method_types.zip(es).map do |method_type, es|
-              msg = +"method_type=`#{method_type}`"
-              details = es.map do |e|
-                "\"#{Errors.to_string(e).sub("#{tag} ", "") }\""
-              end.join(', ')
-              msg << " details=[#{details}]"
-            end.join(', ')
-            message
-          end
-          errors << error
-        end
-
-        errors
-      end
-
-      def method_call(method_name, method_type, call, errors:)
-        return errors if method_type.type.is_a?(Types::UntypedFunction)
-
-        args(method_name, method_type, method_type.type, call.method_call, errors, type_error: Errors::ArgumentTypeError, argument_error: Errors::ArgumentError)
-        self.return(method_name, method_type, method_type.type, call.method_call, errors, return_error: Errors::ReturnTypeError)
-
-        if method_type.block
-          case
-          when !call.block_calls.empty?
-            call.block_calls.each do |block_call|
-              args(method_name, method_type, method_type.block.type, block_call, errors, type_error: Errors::BlockArgumentTypeError, argument_error: Errors::BlockArgumentError)
-              self.return(method_name, method_type, method_type.block.type, block_call, errors, return_error: Errors::BlockReturnTypeError)
-            end
-          when !call.block_given
-            # Block is not given
-            if method_type.block.required
-              errors << Errors::MissingBlockError.new(klass: self_class, method_name: method_name, method_type: method_type)
-            end
-          else
-            # Block is given, but not yielded
-          end
-        else
-          if call.block_given
-            errors << Errors::UnexpectedBlockError.new(klass: self_class, method_name: method_name, method_type: method_type)
-          end
-        end
-
-        errors
-      end
-
-      def args(method_name, method_type, fun, call, errors, type_error:, argument_error:)
-        test = zip_args(call.arguments, fun) do |val, param|
-          unless self.value(val, param.type)
-            errors << type_error.new(klass: self_class,
-                                     method_name: method_name,
-                                     method_type: method_type,
-                                     param: param,
-                                     value: val)
-          end
-        end
-
-        unless test
-          errors << argument_error.new(klass: self_class,
-                                       method_name: method_name,
-                                       method_type: method_type)
-        end
-      end
-
-      def return(method_name, method_type, fun, call, errors, return_error:)
-        if call.return?
-          unless value(call.return_value, fun.return_type)
-            errors << return_error.new(klass: self_class,
-                                       method_name: method_name,
-                                       method_type: method_type,
-                                       type: fun.return_type,
-                                       value: call.return_value)
-          end
-        end
-      end
-
-      def zip_keyword_args(hash, fun)
-        fun.required_keywords.each do |name, param|
-          if hash.key?(name)
-            yield(hash[name], param)
-          else
-            return false
-          end
-        end
-
-        fun.optional_keywords.each do |name, param|
-          if hash.key?(name)
-            yield(hash[name], param)
-          end
-        end
-
-        hash.each do |name, value|
-          next if fun.required_keywords.key?(name)
-          next if fun.optional_keywords.key?(name)
-
-          if fun.rest_keywords
-            yield value, fun.rest_keywords
-          else
-            return false
-          end
-        end
-
-        true
-      end
-
-      def keyword?(value)
-        Hash === value && value.each_key.all?(Symbol)
-      end
-
-      def zip_args(args, fun, &block)
-        return true if fun.is_a?(Types::UntypedFunction)
-
-        case
-        when args.empty?
-          if fun.required_positionals.empty? && fun.trailing_positionals.empty? && fun.required_keywords.empty?
-            true
-          else
-            false
-          end
-        when !fun.required_positionals.empty?
-          yield_self do
-            param, fun_ = fun.drop_head
-            yield(args.first, param)
-            zip_args(args.drop(1), fun_, &block)
-          end
-        when fun.has_keyword?
-          yield_self do
-            hash = args.last
-            if keyword?(hash)
-              zip_keyword_args(hash, fun, &block) &&
-                zip_args(args.take(args.size - 1),
-                         fun.update(required_keywords: {}, optional_keywords: {}, rest_keywords: nil),
-                         &block)
-            else
-              fun.required_keywords.empty? &&
-                zip_args(args,
-                         fun.update(required_keywords: {}, optional_keywords: {}, rest_keywords: nil),
-                         &block)
-            end
-          end
-        when !fun.trailing_positionals.empty?
-          yield_self do
-            param, fun_ = fun.drop_tail
-            yield(args.last, param)
-            zip_args(args.take(args.size - 1), fun_, &block)
-          end
-        when !fun.optional_positionals.empty?
-          yield_self do
-            param, fun_ = fun.drop_head
-            yield(args.first, param)
-            zip_args(args.drop(1), fun_, &block)
-          end
-        when fun.rest_positionals
-          yield_self do
-            yield(args.first, fun.rest_positionals)
-            zip_args(args.drop(1), fun, &block)
-          end
-        else
-          false
-        end
-      end
-
-      def each_sample(array, &block)
-        if block
-          if sample_size && array.size > sample_size
-            if sample_size > 0
-              size = array.size
-              sample_size.times do
-                yield array[rand(size)]
-              end
-            end
-          else
-            array.each(&block)
-          end
-        else
-          enum_for :each_sample, array
-        end
-      end
-
-      def get_class(type_name)
-        Object.const_get(type_name.to_s)
-      rescue NameError
-        nil
-      end
-
-      def is_double?(value)
-        unchecked_classes.any? { |unchecked_class| Test.call(value, IS_AP, Object.const_get(unchecked_class))}
-      rescue NameError
-        false
-      end
-
-      def value(val, type)
-        if is_double?(val)
-          RBS.logger.info("A double (#{val.inspect}) is detected!")
-          return true
-        end
-
-        case type
-        when Types::Bases::Any
-          true
-        when Types::Bases::Bool
-          val.is_a?(TrueClass) || val.is_a?(FalseClass)
-        when Types::Bases::Top
-          true
-        when Types::Bases::Bottom
-          false
-        when Types::Bases::Void
-          true
-        when Types::Bases::Self
-          Test.call(val, IS_AP, self_class)
-        when Types::Bases::Nil
-          Test.call(val, IS_AP, ::NilClass)
-        when Types::Bases::Class
-          Test.call(val, IS_AP, class_class)
-        when Types::Bases::Instance
-          Test.call(val, IS_AP, instance_class)
-        when Types::ClassInstance
-          klass = get_class(type.name) or return false
-          if params = builder.env.normalized_module_class_entry(type.name.absolute!)&.type_params
-            args = AST::TypeParam.normalize_args(params, type.args)
-            unless args == type.args
-              type = Types::ClassInstance.new(name: type.name, args: args, location: type.location)
-            end
-          end
-
-          case
-          when klass == ::Array
-            Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
-          when klass == ::Hash
-            Test.call(val, IS_AP, klass) && each_sample(val.keys).all? do |key|
-              value(key, type.args[0]) && value(val[key], type.args[1])
-            end
-          when klass == ::Range
-            Test.call(val, IS_AP, klass) && value(val.begin, type.args[0]) && value(val.end, type.args[0])
-          when klass == ::Enumerator
-            if Test.call(val, IS_AP, klass)
-              case val.size
-              when Float::INFINITY
-                values = []
-                ret = self
-                val.lazy.take(10).each do |*args|
-                  values << args
-                  nil
-                end
-              else
-                values = []
-                ret = val.each do |*args|
-                  values << args
-                  nil
-                end
-              end
-
-              value_check = values.empty? || each_sample(values).all? do |v|
-                if v.size == 1
-                  # Only one block argument.
-                  value(v[0], type.args[0]) || value(v, type.args[0])
-                else
-                  value(v, type.args[0])
-                end
-              end
-
-              return_check = if ret.equal?(self)
-                type.args[1].is_a?(Types::Bases::Bottom)
-              else
-                value(ret, type.args[1])
-              end
-
-              value_check && return_check
-            end
-          else
-            Test.call(val, IS_AP, klass)
-          end
-        when Types::ClassSingleton
-          klass = get_class(type.name) or return false
-          singleton_class = begin
-                              klass.singleton_class
-                            rescue TypeError
-                              return false
-                            end
-          val.is_a?(singleton_class)
-        when Types::Interface
-          if (definition = builder.build_interface(type.name.absolute!))
-            definition.methods.each.all? do |method_name, method|
-              next false unless Test.call(val, RESPOND_TOP, method_name)
-
-              meth = Test.call(val, METHOD, method_name)
-              method.defs.all? do |type_def|
-                type_def.member.overloads.all? do |overload|
-                  callable_argument?(meth.parameters, overload.method_type)
-                end
-              end
-            end
-          end
-        when Types::Variable
-          true
-        when Types::Literal
-          type.literal == val
-        when Types::Union
-          type.types.any? {|type| value(val, type) }
-        when Types::Intersection
-          type.types.all? {|type| value(val, type) }
-        when Types::Optional
-          Test.call(val, IS_AP, ::NilClass) || value(val, type.type)
-        when Types::Alias
-          value(val, builder.expand_alias2(type.name.absolute!, type.args))
-        when Types::Tuple
-          Test.call(val, IS_AP, ::Array) &&
-            type.types.map.with_index {|ty, index| value(val[index], ty) }.all?
-        when Types::Record
-          Test::call(val, IS_AP, ::Hash) &&
-            type.fields.map {|key, type| value(val[key], type) }.all?
-        when Types::Proc
-          Test::call(val, IS_AP, ::Proc)
-        else
-          false
-        end
-      end
-
-      private
-
-      def callable_argument?(parameters, method_type)
-        fun = method_type.type
-        take_has_rest = !!parameters.find { |(op, _)| op == :rest }
-
-        return true if fun.is_a?(Types::UntypedFunction)
-
-        fun.required_positionals.each do
-          op, _ = parameters.first
-          return false if op.nil? || op == :keyreq || op == :key || op == :keyrest
-          parameters.shift if op == :req || op == :opt
-        end
-
-        fun.optional_positionals.each do
-          op, _ = parameters.first
-          return false if op.nil? || op == :req || op == :keyreq || op == :key || op == :keyrest
-          parameters.shift if op == :opt
-        end
-
-        if fun.rest_positionals
-          op, _ = parameters.shift
-          return false if op.nil? || op != :rest
-        end
-
-        fun.trailing_positionals.each do
-          op, _ = parameters.first
-          return false if !take_has_rest && (op.nil? || op == :keyreq || op == :key || op == :keyrest)
-          index = parameters.find_index { |(op, _)| op == :req }
-          parameters.delete_at(index) if index
-        end
-
-        if fun.has_keyword?
-          return false if !take_has_rest && parameters.empty?
-
-          fun.required_keywords.each do |name, _|
-            return false if !take_has_rest && parameters.empty?
-            index = parameters.find_index { |(op, n)| (op == :keyreq || op == :key) && n == name }
-            parameters.delete_at(index) if index
-          end
-
-          if !fun.optional_keywords.empty?
-            fun.optional_keywords.each do |name, _|
-              return false if !take_has_rest && parameters.empty?
-              index = parameters.find_index { |(op, n)| op == :key && n == name }
-              parameters.delete_at(index) if index
-            end
-            op, _ = parameters.first
-            return false if op == :req
-          end
-
-          if fun.rest_keywords
-            op, _ = parameters.first
-            return false if (!take_has_rest && op.nil?)
-            # f(a) allows (Integer, a: Integer)
-            return false if op == :req && fun.required_keywords.empty?
-          end
-
-          op, _ = parameters.first
-          return true if (op == :req || op == :opt) && parameters.length == 1
-        end
-
-        # rest required arguments
-        op, _ = parameters.first
-        return false if op == :req || op == :keyreq
-
-        true
-      end
-    end
-  end
-end

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

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require "securerandom"
-require "rbs/test/guaranteed"
-require "rbs/test/observer"
-require "rbs/test/errors"
-require "rbs/test/type_check"
-require "rbs/test/tester"
-require "rbs/test/hook"
-require "rbs/test/setup_helper"
-
-module RBS
-  module Test
-    IS_AP = Kernel.instance_method(:is_a?)
-    DEFINE_METHOD = Module.instance_method(:define_method)
-    INSTANCE_EVAL = BasicObject.instance_method(:instance_eval)
-    INSTANCE_EXEC = BasicObject.instance_method(:instance_exec)
-    METHOD = Kernel.instance_method(:method)
-    CLASS = Kernel.instance_method(:class)
-    SINGLETON_CLASS = Kernel.instance_method(:singleton_class)
-    PP = Kernel.instance_method(:pp)
-    INSPECT = Kernel.instance_method(:inspect)
-    METHODS = Kernel.instance_method(:methods)
-    RESPOND_TOP = Kernel.instance_method(:respond_to?)
-
-    class ArgumentsReturn
-      include Guaranteed::Inspect
-
-      attr_reader :arguments
-      attr_reader :exit_value
-      attr_reader :exit_type
-
-      def initialize(arguments:, exit_value:, exit_type:)
-        @arguments = arguments
-        @exit_value = exit_value
-        @exit_type = exit_type
-      end
-
-      def self.return(arguments:, value:)
-        new(arguments: arguments, exit_value: value, exit_type: :return)
-      end
-
-      def self.exception(arguments:, exception:)
-        new(arguments: arguments, exit_value: exception, exit_type: :exception)
-      end
-
-      def self.break(arguments:)
-        new(arguments: arguments, exit_value: nil, exit_type: :break)
-      end
-
-      def return_value
-        raise unless exit_type == :return
-        exit_value
-      end
-
-      def exception
-        raise unless exit_type == :exception
-        exit_value
-      end
-
-      def return?
-        exit_type == :return
-      end
-
-      def exception?
-        exit_type == :exception
-      end
-
-      def break?
-        exit_type == :break
-      end
-    end
-
-    CallTrace = Struct.new(:method_name, :method_call, :block_calls, :block_given, keyword_init: true)
-
-    class <<self
-      attr_accessor :suffix
-
-      def reset_suffix
-        self.suffix = "RBS_TEST_#{SecureRandom.hex(3)}"
-      end
-    end
-
-    reset_suffix
-
-    if ::UnboundMethod.instance_methods.include?(:bind_call)
-      def self.call(receiver, method, *args, &block)
-        __skip__ = method.bind_call(receiver, *args, &block)
-      end
-    else
-      def self.call(receiver, method, *args, &block)
-        __skip__ = method.bind(receiver).call(*args, &block)
-      end
-    end
-  end
-end
-
-unless ::Module.private_instance_methods.include?(:ruby2_keywords)
-  class Module
-    private
-    def ruby2_keywords(*)
-    end
-  end
-end
-
-unless ::Proc.instance_methods.include?(:ruby2_keywords)
-  class Proc
-    def ruby2_keywords
-      self
-    end
-  end
-end

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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class TypeAliasDependency
-    attr_reader :env
-
-    # Direct dependencies corresponds to a directed graph
-    # with vertices as types and directions based on assignment of types
-    attr_reader :direct_dependencies
-    # A hash which stores the transitive closure
-    # of the directed graph
-    attr_reader :dependencies
-
-    def initialize(env:)
-      @env = env
-    end
-
-    # Check if an alias type definition is circular & prohibited
-    def circular_definition?(alias_name)
-      # Construct transitive closure, if not constructed already
-      transitive_closure() unless @dependencies
-
-      alias_name = env.normalize_type_name!(alias_name)
-      @dependencies[alias_name][alias_name]
-    end
-
-    def build_dependencies
-      return if @direct_dependencies
-
-      # Initialize hash(a directed graph)
-      @direct_dependencies = {}
-      # Initialize dependencies as an empty hash
-      @dependencies = {}
-      # Iterate over alias declarations inserted into environment
-      env.type_alias_decls.each do |name, entry|
-        # Construct a directed graph by recursively extracting type aliases
-        @direct_dependencies[name] = direct_dependency(entry.decl.type)
-        # Initialize dependencies with an empty hash
-        @dependencies[name] = {}
-      end
-    end
-
-    def transitive_closure
-      # Construct a graph of direct dependencies
-      build_dependencies()
-      # Construct transitive closure by using DFS(recursive technique)
-      @direct_dependencies.each_key do |name|
-        dependency(name, name)
-      end
-    end
-
-    def direct_dependencies_of(name)
-      name = env.normalize_type_name!(name)
-      @direct_dependencies[name]
-    end
-
-    def dependencies_of(name)
-      name = env.normalize_type_name!(name)
-      @dependencies[name].each_key.to_set
-    end
-
-    private
-
-    # Constructs directed graph recursively
-    def direct_dependency(type, result = Set[])
-      case type
-      when RBS::Types::Union, RBS::Types::Intersection, RBS::Types::Optional
-        # Iterate over nested types & extract type aliases recursively
-        type.each_type do |nested_type|
-          direct_dependency(nested_type, result)
-        end
-      when RBS::Types::Alias
-        # Append type name if the type is an alias
-        result << env.normalize_type_name(type.name)
-      end
-
-      result
-    end
-
-    # Recursive function to construct transitive closure
-    def dependency(start, vertex, nested = nil)
-      if (start == vertex)
-        if (@direct_dependencies[start].include?(vertex) || nested)
-          # Mark a vertex as connected to itself
-          # if it is connected as an edge || a path(traverse multiple edges)
-          @dependencies[start][vertex] = true
-        end
-      else
-        # Mark a pair of vertices as connected while recursively performing DFS
-        @dependencies[start][vertex] = true
-      end
-
-      # Iterate over the direct dependencies of the vertex
-      @direct_dependencies[vertex]&.each do |type_name|
-        # Invoke the function unless it is already checked
-        dependency(start, type_name, start == type_name) unless @dependencies[start][type_name]
-      end
-    end
-  end
-end