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

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

@@ -0,0 +1,83 @@
+# 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

@@ -0,0 +1,201 @@
+# 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

@@ -0,0 +1,80 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,212 @@
+# 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

@@ -0,0 +1,19 @@
+# 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