raap 0.1.0

data/lib/raap/method_property.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RaaP
+  class MethodProperty
+    class Stats < Struct.new(:success, :skip, :exception)
+      def initialize(success: 0, skip: 0, exception: 0)
+        super
+      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:)
+      @receiver_type = receiver_type
+      @method_name = method_name
+      @method_type = method_type
+      @size_step = size_step
+      @timeout = timeout
+    end
+
+    def run
+      stats = Stats.new
+      if receiver_type.type.to_s == 'String' && method_name == :initialize
+        return stats
+      end
+      begin
+        Timeout.timeout(@timeout) do
+          catch(:break) do
+            @size_step.each do |size|
+              yield call(size: size, stats: stats)
+            end
+          end
+        end
+      rescue Timeout::Error => exception
+        RaaP.logger.warn "Timeout: #{exception}"
+      end
+      stats
+    end
+
+    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
+      check = false
+      if return_type.instance_of?(::RBS::Types::Bases::Bottom)
+        begin
+          return_value = SymbolicCaller.new(symbolic_call).eval
+        rescue => e
+          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:)
+      end
+      if check
+        stats.success += 1
+        Result::Success.new(method_value:, return_value:)
+      else
+        Result::Failure.new(method_value:, return_value:, symbolic_call:)
+      end
+    rescue NoMethodError => exception
+      stats.skip += 1
+      Result::Skip.new(method_value:, 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:)
+    rescue SystemStackError => exception
+      stats.skip += 1
+      RaaP.logger.warn "Found recursive type definition."
+      Result::Skip.new(method_value: nil, exception:)
+    rescue TypeError => exception
+      Result::Failure.new(method_value:, return_value:, symbolic_call:)
+    rescue => exception
+      stats.exception += 1
+      Result::Exception.new(method_value:, exception:)
+    end
+
+    def check_return(receiver_value:, return_value:, method_type:)
+      if BindCall.is_a?(receiver_value, Module)
+        if BindCall.is_a?(return_type, ::RBS::Types::ClassSingleton)
+          # ::RBS::Test::TypeCheck cannot support to check singleton class
+          return receiver_value == return_value
+        end
+        self_class = receiver_value
+        instance_class = receiver_value
+      else
+        self_class = BindCall.class(receiver_value)
+        instance_class = BindCall.class(receiver_value)
+      end
+      type_check = ::RBS::Test::TypeCheck.new(
+        self_class: self_class,
+        instance_class: instance_class,
+        class_class: Module,
+        builder: RBS.builder,
+        sample_size: 1,
+        unchecked_classes: []
+      )
+      begin
+        type_check.value(return_value, return_type)
+      rescue => e
+        $stderr.puts "Type check fail by `(#{e.class}) #{e.message}`"
+        false
+      end
+    end
+
+    def return_type
+      method_type.rbs.type.return_type
+    end
+  end
+end

data/lib/raap/method_type.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RaaP
+  class MethodType
+    attr_reader :rbs
+
+    def initialize(method, type_params_decl: [], type_args: [], self_type: nil, instance_type: nil, class_type: nil)
+      rbs =
+        case method
+        when ""
+          raise ArgumentError, "method type is empty"
+        when String
+          ::RBS::Parser.parse_method_type(method, require_eof: true) or raise
+        when ::RBS::MethodType
+          method
+        else
+          raise "bad method #{method}"
+        end
+      ts = TypeSubstitution.new(type_params_decl + rbs.type_params, type_args)
+
+      @rbs = ts.method_type_sub(rbs, self_type:, instance_type:, class_type:)
+      @fun_type = FunctionType.new(@rbs.type)
+    end
+
+    def pick_arguments(size: 10, eval: true)
+      args, kwargs = @fun_type.pick_arguments(size: size, eval:)
+      block = pick_block(size: size, eval:)
+
+      [args, kwargs, block]
+    end
+
+    def pick_block(size: 10, eval: true)
+      block = @rbs.block
+      return nil if block.nil?
+      return nil if (block.required == false) && [true, false].sample
+
+      Proc.new { Type.new(block.type.return_type).pick(size:, eval:) }
+    end
+  end
+end

data/lib/raap/method_value.rb

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

data/lib/raap/rbs.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RaaP
+  module RBS
+    def self.builder
+      @builder ||= ::RBS::DefinitionBuilder.new(env: env.resolve_type_names)
+    end
+
+    def self.env
+      @env ||= ::RBS::Environment.from_loader(loader)
+    end
+
+    def self.loader
+      @loader ||= ::RBS::CLI::LibraryOptions.new.loader
+    end
+
+    def self.parse_type(type)
+      raise ArgumentError, "empty type" if type == ""
+
+      ::RBS::Parser.parse_type(type, require_eof: true) or raise
+    end
+  end
+end

data/lib/raap/result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RaaP
+  module Result
+    module CalledStr
+      def called_str
+        "#{method_value.call_str} -> #{return_value.inspect}[#{return_value.class}]"
+      end
+    end
+
+    Success = Data.define(:method_value, :return_value)
+    Success.include CalledStr
+    Failure = Data.define(:method_value, :return_value, :symbolic_call)
+    Failure.include CalledStr
+    Skip = Data.define(:method_value, :exception)
+    Exception = Data.define(:method_value, :exception)
+  end
+end

data/lib/raap/sized.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RaaP
+  class Sized
+    def initialize(&block)
+      raise LocalJumpError, "no block given" unless block
+      @block = block
+      @such_that = nil
+    end
+
+    def pick(size:)
+      such_that_loop do |skip|
+        @block.call(size + skip)
+      end
+    end
+
+    def such_that(&block)
+      @such_that = block
+      self
+    end
+    alias when such_that
+
+    private
+
+    def such_that_loop
+      skip = 0
+      while skip < 100
+        picked = yield(skip)
+        such_that = @such_that
+        return picked if such_that.nil? || such_that.call(picked)
+        skip += 1
+        raise "too many skips" unless skip < 100
+      end
+      raise "never reached"
+    end
+  end
+end

data/lib/raap/symbolic_caller.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RaaP
+  # sc = SymbolicCaller.new(
+  #   [:call,
+  #     [:call, C, :new, [], {
+  #       a: [:call, A, :new, [], {}, nil],
+  #       b: [:call, B, :new, [], {}, nil] }, nil],
+  #     :run, [], {}, nil]
+  # sc.eval #=> 123
+  #
+  # sc.to_lines
+  # ↓
+  # a = A.new(1)
+  # b = B.new(b: 'bbb')
+  # c = C.new(a: a, b: b)
+  # c.run() { }
+  class SymbolicCaller
+    attr_reader :symbolic_call
+
+    def initialize(symbolic_call)
+      @symbolic_call = symbolic_call
+    end
+
+    def eval
+      walk do |symbolic_call|
+        eval_one(symbolic_call)
+      end
+    end
+
+    def walk(&)
+      _walk(@symbolic_call, &)
+    end
+
+    def to_lines
+      [].tap do |lines|
+        walk do |symbolic_call|
+          symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
+
+          is_mod = receiver_value.is_a?(Module)
+
+          if receiver_value == Kernel
+            var = "#{var_name(method_name)} = "
+            receiver = ''
+          elsif is_mod
+            var = "#{var_name(receiver_value)} = "
+            receiver = receiver_value.name + '.'
+          else
+            var = ""
+            receiver = if printable?(receiver_value)
+              printable(receiver_value) + '.'
+            else
+              var_name(receiver_value.class) + '.'
+            end
+          end
+
+          arguments = []
+          arguments << args.map { |a| printable(a) } if !args.empty?
+          arguments << kwargs.map{|k,v| "#{k}: #{printable(v)}" }.join(', ') if !kwargs.empty?
+          block_str = block ? " { }" : ""
+
+          lines << "#{var}#{receiver}#{method_name}(#{arguments.join(', ')})#{block_str}"
+
+          eval_one(symbolic_call)
+        end
+      end
+    end
+
+    private
+
+    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)
+
+      case symbolic_call
+      in [:call, receiver, Symbol => method_name, Array => args, Hash => kwargs, b]
+        receiver = _walk(receiver, &block)
+        args = _walk(args, &block) if !args.empty?
+        kwargs = _walk(kwargs, &block) if !kwargs.empty?
+        block.call [:call, receiver, method_name, args, kwargs, b]
+      in Array
+        symbolic_call.map { |sc| _walk(sc, &block) }
+      in Hash
+        symbolic_call.transform_values { |sc| _walk(sc, &block) }
+      else
+        symbolic_call
+      end
+    end
+
+    def eval_one(symbolic_call)
+      symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
+
+      begin
+        receiver_value.__send__(method_name, *args, **kwargs, &block)
+      rescue => e
+        RaaP.logger.error("Cannot eval symbolic call #{symbolic_call} with #{e.class}")
+        raise
+      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
+        true
+      else
+        false
+      end
+    end
+
+    def printable(obj)
+      case obj
+      # Object from which it can get strings that can be eval with `#inspect`
+      when Symbol, Integer, Float, Regexp, nil, true, false
+        obj.inspect
+      when String
+        obj.inspect.gsub('"', "'") or raise
+      when Module
+        BindCall.name(obj) or raise
+      else
+        var_name(obj.class)
+      end
+    end
+  end
+end