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

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

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class Substitution
-    attr_reader :mapping
-    attr_accessor :instance_type
-
-    def empty?
-      mapping.empty? && instance_type.nil?
-    end
-
-    def initialize()
-      @mapping = {}
-    end
-
-    def add(from:, to:)
-      mapping[from] = to
-    end
-
-    def self.build(variables, types, instance_type: nil, &block)
-      unless variables.size == types.size
-        raise "Broken substitution: variables=#{variables}, types=#{types}"
-      end
-
-      mapping = variables.zip(types).to_h
-
-      self.new.tap do |subst|
-        mapping.each do |v, t|
-          type = block_given? ? yield(t) : t
-          subst.add(from: v, to: type)
-        end
-
-        subst.instance_type = instance_type
-      end
-    end
-
-    def apply(ty)
-      case ty
-      when Types::Variable
-        # @type var ty: Types::Variable
-        mapping[ty.name] || ty
-      when Types::Bases::Instance
-        if t = instance_type
-          t
-        else
-          ty
-        end
-      else
-        ty
-      end
-    end
-
-    alias [] apply
-
-    def without(*vars)
-      Substitution.new.tap do |subst|
-        subst.mapping.merge!(mapping)
-        vars.each do |var|
-          subst.mapping.delete(var)
-        end
-
-        subst.instance_type = self.instance_type
-      end
-    end
-
-    def +(other)
-      return self if other.empty?
-      return other if self.empty?
-
-      Substitution.new.tap do |subst|
-        subst.mapping.merge!(mapping)
-
-        other.mapping.each do |var, type|
-          if mapping.key?(var)
-            subst.add(from: var, to: self[type])
-          else
-            subst.add(from: var, to: type)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  class Subtractor
-    def initialize(minuend, subtrahend)
-      @minuend = minuend
-      @subtrahend = subtrahend
-    end
-
-    def call(minuend = @minuend, context: nil)
-      minuend.map do |decl|
-        case decl
-        when AST::Declarations::Constant
-          name = absolute_typename(decl.name, context: context)
-          decl unless @subtrahend.constant_name?(name)
-        when AST::Declarations::Interface
-          name = absolute_typename(decl.name, context: context)
-          decl unless @subtrahend.interface_name?(name)
-        when AST::Declarations::Class, AST::Declarations::Module
-          name = absolute_typename(decl.name, context: context)
-          case
-          when @subtrahend.class_decl?(name) && decl.is_a?(AST::Declarations::Class)
-            filter_members(decl, context: context)
-          when @subtrahend.module_decl?(name) && decl.is_a?(AST::Declarations::Module)
-            filter_members(decl, context: context)
-          when @subtrahend.constant_name?(name)
-            nil
-          else
-            decl
-          end
-        when AST::Declarations::Global
-          decl unless @subtrahend.global_decls[decl.name]
-        when AST::Declarations::TypeAlias
-          name = absolute_typename(decl.name, context: context)
-          decl unless @subtrahend.type_alias_decls[name]
-        when AST::Declarations::ClassAlias
-          name = absolute_typename(decl.new_name, context: context)
-          decl unless @subtrahend.class_alias?(name) || @subtrahend.class_decl?(name)
-        when AST::Declarations::ModuleAlias
-          name = absolute_typename(decl.new_name, context: context)
-          decl unless @subtrahend.module_alias?(name) || @subtrahend.module_decl?(name)
-        else
-          raise "unknwon decl: #{(_ = decl).class}"
-        end
-      end.compact
-    end
-
-    private def filter_members(decl, context:)
-      owner = absolute_typename(decl.name, context: context)
-
-      context = _ = [context, decl.name]
-      children = call(decl.each_decl.to_a, context: context) +
-        decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
-      children = filter_redundunt_access_modifiers(children)
-      return nil if children.empty?
-
-      update_decl(decl, members: children)
-    end
-
-    private def member_exist?(owner, member, context:)
-      case member
-      when AST::Members::MethodDefinition
-        method_exist?(owner, member.name, member.kind)
-      when AST::Members::Alias
-        method_exist?(owner, member.new_name, member.kind)
-      when AST::Members::AttrReader
-        method_exist?(owner, member.name, member.kind)
-      when AST::Members::AttrWriter
-        method_exist?(owner, :"#{member.name}=", member.kind)
-      when AST::Members::AttrAccessor
-        # TODO: It unexpectedly removes attr_accessor even if either reader or writer does not exist in the subtrahend.
-        method_exist?(owner, member.name, member.kind) || method_exist?(owner, :"#{member.name}=", member.kind)
-      when AST::Members::InstanceVariable
-        ivar_exist?(owner, member.name, :instance)
-      when AST::Members::ClassInstanceVariable
-        ivar_exist?(owner, member.name, :singleton)
-      when AST::Members::ClassVariable
-        cvar_exist?(owner, member.name)
-      when AST::Members::Include, AST::Members::Extend, AST::Members::Prepend
-        mixin_exist?(owner, member, context: context)
-      when AST::Members::Public, AST::Members::Private
-        # They should not be removed even if the subtrahend has them.
-        false
-      else
-        raise "unknown member: #{(_ = member).class}"
-      end
-    end
-
-    private def method_exist?(owner, method_name, kind)
-      each_member(owner).any? do |m|
-        case m
-        when AST::Members::MethodDefinition
-          m.name == method_name && m.kind == kind
-        when AST::Members::Alias
-          m.new_name == method_name && m.kind == kind
-        when AST::Members::AttrReader
-          m.name == method_name && m.kind == kind
-        when AST::Members::AttrWriter
-          :"#{m.name}=" == method_name && m.kind == kind
-        when AST::Members::AttrAccessor
-          (m.name == method_name || :"#{m.name}=" == method_name) && m.kind == kind
-        end
-      end
-    end
-
-    private def ivar_exist?(owner, name, kind)
-      each_member(owner).any? do |m|
-        case m
-        when AST::Members::InstanceVariable
-          m.name == name
-        when AST::Members::Attribute
-          ivar_name = m.ivar_name == false ? nil : m.ivar_name || :"@#{m.name}"
-          ivar_name == name && m.kind == kind
-        end
-      end
-    end
-
-    private def cvar_exist?(owner, name)
-      each_member(owner).any? do |m|
-        case m
-        when AST::Members::ClassVariable
-          m.name == name
-        end
-      end
-    end
-
-    private def each_member(owner, &block)
-      return enum_for((__method__ or raise), owner) unless block
-
-      entry = @subtrahend.class_decls[owner]
-      return unless entry
-      decls = entry.decls.map { |d| d.decl }
-
-      decls.each { |d| d.members.each { |m| block.call(m) } }
-    end
-
-    private def mixin_exist?(owner, mixin, context:)
-      candidates = typename_candidates(mixin.name, context: context)
-      each_member(owner).any? do |m|
-        case m
-        when mixin.class
-          # @type var m: AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
-          candidates.include?(m.name)
-        end
-      end
-    end
-
-    private def filter_redundunt_access_modifiers(decls)
-      decls = decls.dup
-      decls.pop while access_modifier?(decls.last)
-      decls = decls.map.with_index do |decl, i|
-        if access_modifier?(decl) && access_modifier?(decls[i + 1])
-          nil
-        else
-          decl
-        end
-      end.compact
-    end
-
-    private def access_modifier?(decl)
-      decl.is_a?(AST::Members::Public) || decl.is_a?(AST::Members::Private)
-    end
-
-    private def update_decl(decl, members:)
-      case decl
-      when AST::Declarations::Class
-        decl.class.new(name: decl.name, type_params: decl.type_params, super_class: decl.super_class,
-                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
-                        members: members)
-      when AST::Declarations::Module
-        decl.class.new(name: decl.name, type_params: decl.type_params, self_types: decl.self_types,
-                        annotations: decl.annotations, location: decl.location, comment: decl.comment,
-                        members: members)
-      end
-    end
-
-    private def absolute_typename(name, context:)
-      while context
-        ns = context[1] or raise
-        name = name.with_prefix(ns.to_namespace)
-        context = _ = context[0]
-      end
-      name.absolute!
-    end
-
-    private def typename_candidates(name, context:)
-      ret = [name.absolute!, name.relative!]
-      return ret if name.absolute?
-
-      while context
-        ns = context[1] or raise
-        name = name.with_prefix(ns.to_namespace)
-        ret.concat [name.absolute!, name.relative!]
-
-        context = _ = context[0]
-      end
-
-      ret
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module Test
-    module Errors
-      ArgumentTypeError =
-        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
-      BlockArgumentTypeError =
-        Struct.new(:klass, :method_name, :method_type, :param, :value, keyword_init: true)
-      ArgumentError =
-        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
-      BlockArgumentError =
-        Struct.new(:klass, :method_name, :method_type, keyword_init: true)
-      ReturnTypeError =
-        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
-      BlockReturnTypeError =
-        Struct.new(:klass, :method_name, :method_type, :type, :value, keyword_init: true)
-
-      UnexpectedBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
-      MissingBlockError = Struct.new(:klass, :method_name, :method_type, keyword_init: true)
-
-      UnresolvedOverloadingError = Struct.new(:klass, :method_name, :method_types, keyword_init: true)
-
-      def self.format_param(param)
-        if param.name
-          "`#{param.type}` (#{param.name})"
-        else
-          "`#{param.type}`"
-        end
-      end
-
-      RESPOND_TO = ::Kernel.instance_method :respond_to?
-      private_constant :RESPOND_TO
-
-      def self.inspect_(obj)
-        if RESPOND_TO.bind_call(obj, :inspect)
-          obj.inspect
-        else
-          Test::INSPECT.bind(obj).call     # For the case inspect is not defined (like BasicObject)
-        end
-      end
-
-      def self.method_tag(error)
-        if error.klass.singleton_class?
-          name = inspect_(error.klass).sub(/\A#<Class:(.*)>\z/, '\1')
-          method_name = ".#{error.method_name}"
-        else
-          name = error.klass.name
-          method_name = "##{error.method_name}"
-        end
-        "[#{name}#{method_name}]"
-      end
-
-      def self.to_string(error)
-        case error
-        when ArgumentTypeError
-          "#{method_tag(error)} ArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
-        when BlockArgumentTypeError
-          "#{method_tag(error)} BlockArgumentTypeError: expected #{format_param error.param} but given `#{inspect_(error.value)}`"
-        when ArgumentError
-          "#{method_tag(error)} ArgumentError: expected method type #{error.method_type}"
-        when BlockArgumentError
-          "#{method_tag(error)} BlockArgumentError: expected method type #{error.method_type}"
-        when ReturnTypeError
-          "#{method_tag(error)} ReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
-        when BlockReturnTypeError
-          "#{method_tag(error)} BlockReturnTypeError: expected `#{error.type}` but returns `#{inspect_(error.value)}`"
-        when UnexpectedBlockError
-          "#{method_tag(error)} UnexpectedBlockError: unexpected block is given for `#{error.method_type}`"
-        when MissingBlockError
-          "#{method_tag(error)} MissingBlockError: required block is missing for `#{error.method_type}`"
-        when UnresolvedOverloadingError
-          "#{method_tag(error)} UnresolvedOverloadingError: couldn't find a suitable overloading"
-        else
-          raise "Unexpected error: #{inspect_(error)}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module Test
-    module Guaranteed
-      module Inspect
-        EQUAL = ::BasicObject.instance_method(:equal?)
-        INSPECT = ::Kernel.instance_method(:inspect)
-        private_constant :EQUAL, :INSPECT
-
-        module_function def guaranteed_inspect(obj)
-          obj.inspect
-        rescue NoMethodError
-          INSPECT.bind_call(obj)
-        end
-
-        def inspect
-          string = "<#{self.class.name}:"
-
-          instance_variables.each_with_index do |variable, index|
-            string.concat ', ' unless index.zero?
-            string.concat "#{variable}: #{guaranteed_inspect(instance_variable_get(variable))}"
-          end
-
-          string.concat '>'
-        end
-      end
-    end
-  end
-end

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

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require "rbs"
-require "pp"
-
-module RBS
-  module Test
-    module Hook
-      OPERATORS = {
-        :[] => "indexlookup",
-        :[]= => "indexset",
-        :== => "eqeq",
-        :=== => "eqeqeq",
-        :!= => "noteq",
-        :+ => "plus",
-        :- => "minus",
-        :* => "star",
-        :/ => "slash",
-        :> => "gt",
-        :>= => "gteq",
-        :< => "lt",
-        :<= => "lteq",
-        :<=> => "ufo",
-        :& => "amp",
-        :| => "vbar",
-        :^ => "hat",
-        :! => "not",
-        :<< => "lshift",
-        :>> => "rshift",
-        :~ => "tilda",
-        :=~ => "eqtilda",
-        :% => "percent",
-        :+@ => "unary_plus",
-        :-@ => "unary_minus"
-      }
-      def self.alias_names(target, random)
-        suffix = "#{RBS::Test.suffix}_#{random}"
-
-        case target
-        when *OPERATORS.keys
-          name = OPERATORS[target]
-          [
-            "#{name}____with__#{suffix}",
-            "#{name}____without__#{suffix}"
-          ]
-        else
-          aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
-
-          [
-            "#{aliased_target}__with__#{suffix}#{punctuation}",
-            "#{aliased_target}__without__#{suffix}#{punctuation}"
-          ]
-        end
-      end
-
-      def self.setup_alias_method_chain(klass, target, random:)
-        with_method, without_method = alias_names(target, random)
-
-        RBS.logger.debug "alias name: #{target}, #{with_method}, #{without_method}"
-
-        klass.instance_eval do
-          alias_method without_method, target
-          alias_method target, with_method
-
-          case
-          when public_method_defined?(without_method)
-            public target
-          when protected_method_defined?(without_method)
-            protected target
-          when private_method_defined?(without_method)
-            private target
-          end
-        end
-      end
-
-      def self.hook_method_source(prefix, method_name, key, random:, params:)
-        with_name, without_name = alias_names(method_name, random)
-        full_method_name = "#{prefix}#{method_name}"
-
-        param_source = params.take_while {|param| param[0] == :req }
-                             .map.with_index {|pair, index| pair[1] || "__req__#{random}__#{index}" }
-        param_source.push("*rest_args__#{random}")
-        block_param = "block__#{random}"
-
-        RBS.logger.debug {
-          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &#{block_param}) ..."
-        }
-
-        [__LINE__ + 1, <<RUBY]
-def #{with_name}(#{param_source.join(", ")}, &#{block_param})
-  args = [#{param_source.join(", ")}]
-  ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
-
-  begin
-    return_from_call = false
-    block_calls = []
-
-    if block_given?
-      block_receives_block = #{block_param}.parameters.last&.yield_self {|type, _| type == :block }
-
-      wrapped_block = Object.new.instance_exec do
-        new_object = self
-
-        proc do |*block_args, &block2|
-          return_from_block = false
-
-          begin
-            block_result = if self.equal?(new_object)
-                            if block_receives_block
-                              #{block_param}.call(*block_args, &block2)
-                            else
-                              yield(*block_args)
-                            end
-                          else
-                            # Detected that `self` inside `proc` is not equal to the `self` outside block (which is saved to `new_object`).
-                            # This means that the block is called with `instance_exec` or `instance_eval`.
-                            self.instance_exec(*block_args, &#{block_param})
-                          end
-
-            return_from_block = true
-          ensure
-            exn = $!
-
-            case
-            when return_from_block
-              # Returned from yield
-              block_calls << ::RBS::Test::ArgumentsReturn.return(
-                arguments: block_args,
-                value: block_result
-              )
-            when exn
-              # Exception
-              block_calls << ::RBS::Test::ArgumentsReturn.exception(
-                arguments: block_args,
-                exception: exn
-              )
-            else
-              # break?
-              block_calls << ::RBS::Test::ArgumentsReturn.break(
-                arguments: block_args
-              )
-            end
-          end
-
-          block_result
-        end.ruby2_keywords
-      end
-
-      result = __send__(:"#{without_name}", *args, &wrapped_block)
-    else
-      result = __send__(:"#{without_name}", *args)
-    end
-    return_from_call = true
-    result
-  ensure
-    exn = $!
-
-    case
-    when return_from_call
-      ::RBS.logger.debug { "#{full_method_name} return with value: " + result.inspect }
-      method_call = ::RBS::Test::ArgumentsReturn.return(
-        arguments: args,
-        value: result
-      )
-    when exn
-      ::RBS.logger.debug { "#{full_method_name} exit with exception: " + exn.inspect }
-      method_call = ::RBS::Test::ArgumentsReturn.exception(
-        arguments: args,
-        exception: exn
-      )
-    else
-      ::RBS.logger.debug { "#{full_method_name} exit with jump" }
-      method_call = ::RBS::Test::ArgumentsReturn.break(arguments: args)
-    end
-
-    trace = ::RBS::Test::CallTrace.new(
-      method_name: #{method_name.inspect},
-      method_call: method_call,
-      block_calls: block_calls,
-      block_given: block_given?,
-    )
-
-    ::RBS::Test::Observer.notify(#{key.inspect}, self, trace)
-  end
-
-  result
-end
-
-ruby2_keywords :#{with_name}
-RUBY
-      end
-
-      def self.hook_instance_method(klass, method, key:)
-        random = SecureRandom.hex(4)
-        params = klass.instance_method(method).parameters
-        line, source = hook_method_source("#{klass}#", method, key, random: random, params: params)
-
-        klass.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass, method, random: random
-      end
-
-      def self.hook_singleton_method(klass, method, key:)
-        random = SecureRandom.hex(4)
-        params = klass.method(method).parameters
-        line, source = hook_method_source("#{klass}.",method, key, random: random, params: params)
-
-        klass.singleton_class.module_eval(source, __FILE__, line)
-        setup_alias_method_chain klass.singleton_class, method, random: random
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module RBS
-  module Test
-    module Observer
-      @@observers = {}
-
-      class <<self
-        def notify(key, *args)
-          @@observers[key]&.call(*args)
-        end
-
-        def register(key, object = nil, &block)
-          @@observers[key] = object || block
-        end
-      end
-    end
-  end
-end