raap 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 272cb44584fb297591d356de0c90ecfbcf782951ed4a02432eb4cd87a6849f0f
-  data.tar.gz: d0776eeeb3f840a1730f16a9df385414e3697631191961b986085773cad49e04
+  metadata.gz: 507ed156280ed3e0db1f2eb454bb03c57aa473d537d8c6ea5905ad852eba550d
+  data.tar.gz: 3108fa50c664702f79141a3c0b5e83934d6742468d1d51bfb2febb5b64a00b12
 SHA512:
-  metadata.gz: '09ace505a4973cac5f075a133fc6e13c8fa34bde72adf522cc095ad3accfccec574b3209aaf4bca8deceb398b5b36f0893672722504895d51413c65877efc167'
-  data.tar.gz: 1fe3eb4b5695bd69b2a30fdd2035a81aa3be1a289dee120f4664f95bb1d6d9a5ab8849f11acb957e8ac97e8dfb174f49536542fc96f29ecfade076e15b76619e
+  metadata.gz: 269e220d72b9861881de860a71a2adff318105595880fe73e86492e255c9bb32fbeff7ac3685b83ea11d792a02b1509eb969d9956483a9415608530a3f8806bd
+  data.tar.gz: df4e40973681eb292d7844aa5ed1427b7155f619c6ebea53792149f430ab28e42a0a0f52df9517a3af9af1e08494eaccdd8d4d84313c9d24184f6403a51e1dc5

data/README.md

@@ -78,6 +78,21 @@ For example, an Integer with size zero is `0` and an Array is `[]`.
 
 RaaP, like other property-based tests, changes the size 100 times from 0 to 99 by default to generate test data.
 
+## Symbolic call
+
+You may possibly see the following data structure in the debug logs.
+
+```rb
+[:call, Object, :method, [], {}, nil]
+```
+
+This is a data structure of the state of the method call.
+
+Symbolic call is a tuple beginning with `:call`, followed by the receiver, method name, positional arguments, keyword arguments, and block arguments, in that order.
+And the receiver and arguments are nestable.
+
+It is used in QuickCheck and Proper to keep as much history of method calls as possible.
+
 ## Options
 
 ### `-I PATH` or `--include PATH`

data/lib/raap/cli.rb

@@ -16,6 +16,7 @@ module RaaP
       :size_from,
       :size_to,
       :size_by,
+      :allow_private,
       keyword_init: true
     )
 
@@ -28,6 +29,7 @@ module RaaP
       size_from: 0,
       size_to: 99,
       size_by: 1,
+      allow_private: false,
     )
 
     def initialize(argv)
@@ -60,6 +62,9 @@ module RaaP
         o.on('--size-by int', Integer, "default: #{CLI.option.size_by}") do |arg|
           CLI.option.size_by = arg
         end
+        o.on('--allow-private', "default: #{CLI.option.allow_private}") do
+          CLI.option.allow_private = true
+        end
       end.parse!(@argv)
 
       CLI.option.dirs.each do |dir|
@@ -217,6 +222,7 @@ module RaaP
         ),
         size_step: CLI.option.size_from.step(to: CLI.option.size_to, by: CLI.option.size_by),
         timeout: CLI.option.timeout,
+        allow_private: true,
       ).run do |called|
         case called
         in Result::Success => s
@@ -225,6 +231,9 @@ module RaaP
         in Result::Failure => f
           puts 'F'
           puts "Failed in case of `#{f.called_str}`"
+          if e = f.exception
+            RaaP.logger.debug { "Failure: [#{e.class}] #{e.message}" }
+          end
           puts
           RaaP.logger.debug { PP.pp(f.symbolic_call, ''.dup) }
           puts "### call stack:"
@@ -236,10 +245,13 @@ module RaaP
           throw :break
         in Result::Skip => s
           print 'S'
-          RaaP::logger.debug("Skip: [#{s.exception.class}] #{s.exception.message}")
+          RaaP.logger.debug { PP.pp(s.symbolic_call, ''.dup) }
+          RaaP.logger.debug("Skip: [#{s.exception.class}] #{s.exception.message}")
+          RaaP.logger.debug(s.exception.backtrace.join("\n"))
         in Result::Exception => e
           print 'E'
-          RaaP.logger.info("Exception: [#{e.exception.class}] #{e.exception.message}")
+          RaaP.logger.debug { PP.pp(e.symbolic_call, ''.dup) }
+          RaaP.logger.debug("Exception: [#{e.exception.class}] #{e.exception.message}")
           RaaP.logger.debug(e.exception.backtrace.join("\n"))
         end
       end

data/lib/raap/method_property.rb

@@ -8,18 +8,13 @@ module RaaP
       end
     end
 
-    attr_reader :receiver_type
-    attr_reader :method_name
-    attr_reader :method_type
-    attr_reader :size_step
-    attr_reader :timeout
-
-    def initialize(receiver_type:, method_name:, method_type:, size_step:, timeout:)
+    def initialize(receiver_type:, method_name:, method_type:, size_step:, timeout:, allow_private: false)
       @receiver_type = receiver_type
       @method_name = method_name
       @method_type = method_type
       @size_step = size_step
       @timeout = timeout
+      @allow_private = allow_private
     end
 
     def run
@@ -41,52 +36,53 @@ module RaaP
     private
 
     def call(size:, stats:)
-      receiver_value = receiver_type.pick(size: size, eval: false)
-      arguments = method_type.pick_arguments(size: size, eval: false)
-      method_value = MethodValue.new(receiver_value:, arguments:, method_name:, size:)
-      symbolic_call = method_value.to_symbolic_call
+      receiver_value = @receiver_type.pick(size: size, eval: false)
+      args, kwargs, block = @method_type.pick_arguments(size: size, eval: false)
+      # @type var symbolic_call: symbolic_call
+      symbolic_call = [:call, receiver_value, @method_name, args, kwargs, block]
+      symbolic_caller = SymbolicCaller.new(symbolic_call, allow_private: @allow_private)
       begin
-        # ensure method_value
+        # ensure symbolic_call
         check = false
         if return_type.instance_of?(::RBS::Types::Bases::Bottom)
           begin
-            return_value = SymbolicCaller.new(symbolic_call).eval
-          rescue => e
+            return_value = symbolic_caller.eval
+          rescue StandardError, NotImplementedError
             check = true
             return_value = Value::Bottom.new
           end
         else
-          return_value = SymbolicCaller.new(symbolic_call).eval
-          check = check_return(receiver_value:, return_value:, method_type:)
+          return_value = symbolic_caller.eval
+          check = check_return(receiver_value:, return_value:, method_type: @method_type)
         end
         if check
           stats.success += 1
-          Result::Success.new(method_value:, return_value:)
+          Result::Success.new(symbolic_call:, return_value:)
         else
-          Result::Failure.new(method_value:, return_value:, symbolic_call:)
+          Result::Failure.new(symbolic_call:, return_value:)
         end
       rescue TypeError => exception
-        Result::Failure.new(method_value:, return_value:, symbolic_call:)
+        Result::Failure.new(symbolic_call:, return_value:, exception:)
       end
 
-    # not ensure method_value
+    # not ensure symbolic_call
     rescue NoMethodError => exception
       stats.skip += 1
-      Result::Skip.new(method_value:, exception:)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue NameError => e
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
       RaaP.logger.error("Implementation is not found #{msg} maybe.")
       throw :break
     rescue NotImplementedError => exception
       stats.skip += 1
-      Result::Skip.new(method_value:, exception:)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue SystemStackError => exception
       stats.skip += 1
       RaaP.logger.warn "Found recursive type definition."
-      Result::Skip.new(method_value: nil, exception:)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue => exception
       stats.exception += 1
-      Result::Exception.new(method_value:, exception:)
+      Result::Exception.new(symbolic_call:, exception:)
     end
 
     def check_return(receiver_value:, return_value:, method_type:)
@@ -118,7 +114,7 @@ module RaaP
     end
 
     def return_type
-      method_type.rbs.type.return_type
+      @method_type.rbs.type.return_type
     end
   end
 end

data/lib/raap/result.rb

@@ -4,15 +4,20 @@ module RaaP
   module Result
     module CalledStr
       def called_str
-        "#{method_value.call_str} -> #{return_value.inspect}[#{return_value.class}]"
+        scr = SymbolicCaller.new(symbolic_call)
+        "#{scr.call_str} -> #{return_value.inspect}[#{return_value.class}]"
       end
     end
 
-    Success = Data.define(:method_value, :return_value)
+    Success = Data.define(:symbolic_call, :return_value)
     Success.include CalledStr
-    Failure = Data.define(:method_value, :return_value, :symbolic_call)
+    Failure = Data.define(:symbolic_call, :return_value, :exception) do
+      def initialize(exception: nil, **)
+        super
+      end
+    end
     Failure.include CalledStr
-    Skip = Data.define(:method_value, :exception)
-    Exception = Data.define(:method_value, :exception)
+    Skip = Data.define(:symbolic_call, :exception)
+    Exception = Data.define(:symbolic_call, :exception)
   end
 end

data/lib/raap/symbolic_caller.rb

@@ -32,9 +32,11 @@ module RaaP
     end
 
     attr_reader :symbolic_call
+    attr_reader :allow_private
 
-    def initialize(symbolic_call)
+    def initialize(symbolic_call, allow_private: false)
       @symbolic_call = symbolic_call
+      @allow_private = allow_private
     end
 
     def eval
@@ -43,8 +45,18 @@ module RaaP
       end
     end
 
-    def walk(&)
-      _walk(@symbolic_call, &)
+    def call_str
+      symbolic_call => [:call, receiver, Symbol => method_name, Array => args, Hash => kwargs, b]
+      receiver = try_eval(receiver)
+      args, kwargs, block = try_eval([args, kwargs, block])
+
+      a = []
+      a << args.map(&:inspect).join(', ') if !args.empty?
+      a << kwargs.map { |k ,v| "#{k}: #{BindCall.inspect(v)}" }.join(', ') if !kwargs.empty?
+      argument_str = a.join(', ')
+      block_str = block ? "{ }" : nil
+
+      "#{BindCall.inspect(receiver)}.#{method_name}(#{argument_str})#{block_str}"
     end
 
     def to_lines
@@ -69,13 +81,7 @@ module RaaP
             receiver = receiver_value.name + '.'
           else
             var_eq = ""
-            receiver = if printable?(receiver_value)
-              var = Var.new(printable(receiver_value))
-              var + '.'
-            else
-              var = Var.new(var_name(receiver_value.class))
-              var + '.'
-            end
+            receiver = Var.new(printable(receiver_value)) + '.'
           end
 
           arguments = []
@@ -92,6 +98,16 @@ module RaaP
 
     private
 
+    def try_eval(symbolic_call)
+      SymbolicCaller.new(symbolic_call).eval
+    rescue RuntimeError, NotImplementedError
+      symbolic_call
+    end
+
+    def walk(&)
+      _walk(@symbolic_call, &)
+    end
+
     def _walk(symbolic_call, &block)
       return symbolic_call if BindCall::instance_of?(symbolic_call, BasicObject)
       return symbolic_call if !BindCall.respond_to?(symbolic_call, :deconstruct) && !BindCall.respond_to?(symbolic_call, :deconstruct_keys)
@@ -115,23 +131,22 @@ module RaaP
 
     def eval_one(symbolic_call)
       symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
-      BindCall.public_send(receiver_value, method_name, *args, **kwargs, &block)
+      if @allow_private
+        receiver_value.__send__(method_name, *args, **kwargs, &block)
+      else
+        BindCall.public_send(receiver_value, method_name, *args, **kwargs, &block)
+      end
     end
 
     def var_name(mod)
       printable(mod).gsub('::', '_').downcase
     end
 
-    def printable?(obj)
-      case obj
-      when Symbol, Integer, Float, Regexp, nil, true, false, String, Module, Var
-        true
-      else
-        false
+    def printable(obj)
+      if obj in [:call, _, Symbol, Array, Hash, _]
+        return _walk(obj)
       end
-    end
 
-    def printable(obj)
       case obj
       when Var
         obj.name
@@ -140,6 +155,15 @@ module RaaP
         obj.inspect
       when String
         obj.inspect.gsub('"', "'") or raise
+      when Hash
+        hash_body = obj.map do |k, v|
+          ks = printable(k)
+          vs = printable(v)
+          ks.start_with?(':') ? "#{ks[1..-1]}: #{vs}" : "#{ks} => #{vs}"
+        end
+        "{#{hash_body.join(', ')}}"
+      when Array
+        "[#{obj.map { |o| printable(o) }.join(', ')}]"
       when Module
         BindCall.name(obj) or raise
       else

data/lib/raap/type.rb

@@ -100,7 +100,17 @@ module RaaP
       when ::RBS::Types::Union
         type.types.sample&.then { |t| Type.new(t).pick(size:) }
       when ::RBS::Types::Intersection
-        Value::Intersection.new(type, size: size)
+        [:call, Value::Intersection, :new, [type], {size:}, nil]
+      when ::RBS::Types::Interface
+        [:call, Value::Interface, :new, [type], {size:}, nil]
+      when ::RBS::Types::Variable
+        [:call, Value::Variable, :new, [type], {}, nil]
+      when ::RBS::Types::Bases::Void
+        [:call, Value::Void, :new, [], {}, nil]
+      when ::RBS::Types::Bases::Top
+        [:call, Value::Top, :new, [], {}, nil]
+      when ::RBS::Types::Bases::Bottom
+        [:call, Value::Bottom, :new, [], {}, nil]
       when ::RBS::Types::Optional
         case Random.rand(2)
         in 0 then Type.new(type.type).pick(size:)
@@ -117,10 +127,6 @@ module RaaP
         raise "cannot resolve `instance` type"
       when ::RBS::Types::Bases::Self
         raise "cannot resolve `self` type"
-      when ::RBS::Types::Interface
-        Value::Interface.new(type, size: size)
-      when ::RBS::Types::Variable
-        Value::Variable.new(type)
       when ::RBS::Types::ClassSingleton
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
@@ -136,16 +142,10 @@ module RaaP
         type.literal
       when ::RBS::Types::Bases::Bool
         bool.pick(size: size)
-      when ::RBS::Types::Bases::Void
-        Value::Void.new
       when ::RBS::Types::Bases::Any
         untyped.pick(size: size)
       when ::RBS::Types::Bases::Nil
         nil
-      when ::RBS::Types::Bases::Top
-        Value::Top.new
-      when ::RBS::Types::Bases::Bottom
-        Value::Bottom.new
       else
         raise "not implemented #{type.to_s}"
       end
@@ -177,7 +177,7 @@ module RaaP
           raise
         end
       else
-        Value::Module.new(type)
+        [:call, Value::Module, :new, [type], {}, nil]
       end
     end
 
@@ -313,7 +313,7 @@ module RaaP
       in 5 then symbol
       in 6 then bool
       in 7 then encoding
-      in 8 then sized { BasicObject.new }
+      in 8 then sized { [:call, BasicObject, :new, [], {}, nil] }
       end
     end
 

data/lib/raap/value/module.rb

@@ -1,13 +1,14 @@
 module RaaP
   module Value
     # FIXME: consider self_types
-    class Module < BasicObject
+    # HINT: intersection?
+    class Module
       attr_reader :type
 
       def initialize(type)
         @type = type
         const = ::Object.const_get(type.name.absolute!.to_s)
-        BindCall.extend(self, const)
+        extend(const)
       end
 
       def inspect = "#<module #{@type}>"

data/lib/raap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaaP
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/raap.rb

@@ -23,7 +23,6 @@ module RaaP
   autoload :FunctionType, "raap/function_type"
   autoload :MethodProperty, "raap/method_property"
   autoload :MethodType, "raap/method_type"
-  autoload :MethodValue, "raap/method_value"
   autoload :Minitest, "raap/minitest"
   autoload :RBS, "raap/rbs"
   autoload :Result, "raap/result"

data/sig/raap.rbs

@@ -19,15 +19,15 @@ module RaaP
 
   class CLI
     class Option < ::Struct[untyped]
-      def self.new: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer) -> instance
+      def self.new: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool) -> instance
 
-      def self.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer) -> instance
+      def self.[]: (?dirs: ::Array[String], ?requires: ::Array[String], ?libraries: ::Array[String], ?timeout: (Integer | Float | nil), ?size_from: ::Integer, ?size_to: ::Integer, ?size_by: ::Integer, ?allow_private: bool) -> instance
 
       def self.keyword_init?: () -> true
 
-      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
 
-      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by]
+      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
 
       attr_accessor dirs: ::Array[String]
 
@@ -42,6 +42,8 @@ module RaaP
       attr_accessor size_to: ::Integer
 
       attr_accessor size_by: ::Integer
+
+      attr_accessor allow_private: bool
     end
 
     @argv: Array[String]
@@ -81,12 +83,15 @@ module RaaP
       attr_accessor skip: Integer
       attr_accessor exception: Integer
     end
-    attr_reader receiver_type: Type
-    attr_reader method_name: Symbol
-    attr_reader method_type: MethodType
-    attr_reader size_step: _Each[Integer]
-    attr_reader timeout: (Integer | Float | nil)
-    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil)) -> void
+
+    @receiver_type: Type
+    @method_name: Symbol
+    @method_type: MethodType
+    @size_step: _Each[Integer]
+    @timeout: (Integer | Float | nil)
+    @allow_private: bool
+
+    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil), ?allow_private: bool) -> void
     def run: () { (Result::Success | Result::Failure | Result::Skip | Result::Exception) -> void } -> Stats
 
     private
@@ -106,30 +111,6 @@ module RaaP
     def check_return: (untyped) -> bool
   end
 
-  class MethodValue < Data
-    def self.new: (untyped receiver_value, [Array[untyped], Hash[Symbol, untyped], ::Proc?] arguments, Symbol method_name, Integer size) -> instance
-                | (receiver_value: untyped, arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?], method_name: Symbol, size: Integer) -> instance
-
-    def self.[]: (untyped receiver_value, [Array[untyped], Hash[Symbol, untyped], ::Proc?] arguments, Symbol method_name, Integer size) -> instance
-               | (receiver_value: untyped, arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?], method_name: Symbol, size: Integer) -> instance
-
-    def self.members: () -> [ :receiver_value, :arguments, :method_name, :size ]
-    def members: () -> [ :receiver_value, :arguments, :method_name, :size ]
-
-    attr_reader receiver_value: untyped
-    attr_reader arguments: [Array[untyped], Hash[Symbol, untyped], ::Proc?]
-    attr_reader method_name: Symbol
-    attr_reader size: Integer
-
-    def to_symbolic_call: () -> symbolic_call
-    def call_str: () -> String
-
-    private
-
-    def argument_str: () -> String
-    def block_str: () -> String?
-  end
-
   module Minitest
   end
 
@@ -146,33 +127,33 @@ module RaaP
 
   module Result
     interface _MethodValueReturnValue
-      def method_value: () -> MethodValue
+      def symbolic_call: () -> symbolic_call
       def return_value: () -> untyped
     end
     module CalledStr : _MethodValueReturnValue
       def called_str: () -> String
     end
     class Success < Data
-      def self.new: (method_value: MethodValue, return_value: untyped) -> instance
-      attr_reader method_value: MethodValue
+      def self.new: (symbolic_call: symbolic_call, return_value: untyped) -> instance
+      attr_reader symbolic_call: symbolic_call
       attr_reader return_value: untyped
       include CalledStr
     end
     class Failure < Data
-      def self.new: (method_value: MethodValue, return_value: untyped, symbolic_call: symbolic_call) -> instance
-      attr_reader method_value: MethodValue
-      attr_reader return_value: untyped
+      def self.new: (symbolic_call: symbolic_call, return_value: untyped, ?exception: ::Exception?) -> instance
       attr_reader symbolic_call: symbolic_call
+      attr_reader return_value: untyped
+      attr_reader exception: ::Exception?
       include CalledStr
     end
     class Skip < Data
-      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
-      attr_reader method_value: MethodValue?
+      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
+      attr_reader symbolic_call: symbolic_call?
       attr_reader exception: ::Exception
     end
     class Exception < Data
-      def self.new: (method_value: MethodValue?, exception: ::Exception) -> instance
-      attr_reader method_value: MethodValue?
+      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
+      attr_reader symbolic_call: symbolic_call?
       attr_reader exception: ::Exception
     end
   end
@@ -196,13 +177,17 @@ module RaaP
     end
 
     attr_reader symbolic_call: untyped
-    def initialize: (untyped) -> void
+    attr_reader allow_private: bool
+
+    def initialize: (untyped, ?allow_private: bool) -> void
     def eval: () -> untyped
-    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
+    def call_str: () -> String
     def to_lines: () -> Array[String]
 
     private
 
+    def try_eval: (untyped) -> untyped
+    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
     def _walk: (untyped) ?{ (symbolic_call) -> untyped} -> untyped
     def eval_one: (symbolic_call) -> untyped
     def var_name: (Module) -> String
@@ -301,7 +286,7 @@ module RaaP
       def class: () -> class
     end
 
-    class Module < BasicObject
+    class Module
       attr_reader type: ::RBS::Types::ClassInstance
 
       def initialize: (::RBS::Types::ClassInstance) -> void

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-23 00:00:00.000000000 Z
+date: 2024-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -59,7 +59,6 @@ files:
 - lib/raap/function_type.rb
 - lib/raap/method_property.rb
 - lib/raap/method_type.rb
-- lib/raap/method_value.rb
 - lib/raap/minitest.rb
 - lib/raap/rbs.rb
 - lib/raap/result.rb

data/lib/raap/method_value.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module RaaP
-  class MethodValue < Data.define(
-    :receiver_value,
-    :arguments,
-    :method_name,
-    :size
-  )
-    def to_symbolic_call
-      args, kwargs, block = arguments
-      [:call, receiver_value, method_name, args, kwargs, block]
-    end
-
-    def call_str
-      r = SymbolicCaller.new(receiver_value).eval
-      "#{BindCall.inspect(r)}.#{method_name}(#{argument_str})#{block_str}"
-    end
-
-    private
-
-    def argument_str
-      args, kwargs, _ = SymbolicCaller.new(arguments).eval
-
-      r = []
-      r << args.map(&:inspect).join(', ') if !args.empty?
-      r << kwargs.map { |k ,v| "#{k}: #{BindCall.inspect(v)}" }.join(', ') if !kwargs.empty?
-      r.join(', ')
-    end
-
-    def block_str
-      _, _, block = SymbolicCaller.new(arguments).eval
-      if block
-        "{ }"
-      end
-    end
-  end
-end