raap 0.3.0 → 0.4.0

data/lib/raap/method_property.rb

@@ -2,8 +2,8 @@
 
 module RaaP
   class MethodProperty
-    class Stats < Struct.new(:success, :skip, :exception)
-      def initialize(success: 0, skip: 0, exception: 0)
+    class Stats < Struct.new(:success, :skip, :exception, :break)
+      def initialize(success: 0, skip: 0, exception: 0, break: false)
         super
       end
     end
@@ -23,12 +23,26 @@ module RaaP
         Timeout.timeout(@timeout) do
           catch(:break) do
             @size_step.each do |size|
-              yield call(size: size, stats: stats)
+              call(size:, stats:).tap do |ret|
+                case ret
+                when Result::Success
+                  stats.success += 1
+                when Result::Failure
+                  # no count
+                when Result::Skip
+                  stats.skip += 1
+                when Result::Exception
+                  stats.exception += 1
+                end
+
+                yield ret
+              end
             end
           end
         end
       rescue Timeout::Error => exception
-        RaaP.logger.warn "Timeout: #{exception}"
+        stats.break = true
+        RaaP.logger.info "Timeout: #{exception}"
       end
       stats
     end
@@ -36,61 +50,75 @@ module RaaP
     private
 
     def call(size:, stats:)
-      receiver_value = @receiver_type.pick(size: size, eval: false)
-      args, kwargs, block = @method_type.pick_arguments(size: size, eval: false)
+      if @method_type.rbs.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
+        RaaP.logger.info { "Skip type check since `#{@method_type.rbs}` includes `untyped`" }
+        stats.break = true
+        throw :break
+      end
+      receiver_value = @receiver_type.to_symbolic_call(size:)
+      args, kwargs, block = @method_type.arguments_to_symbolic_call(size:)
       # @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 symbolic_call
-        check = false
+        check = [:failure]
         if return_type.instance_of?(::RBS::Types::Bases::Bottom)
           begin
             return_value = symbolic_caller.eval
           rescue StandardError, NotImplementedError
-            check = true
+            check = [:success]
             return_value = Value::Bottom.new
+          rescue Timeout::ExitException
+            raise
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            RaaP.logger.error("[#{e.class}] class is not supported to check `bot` type")
+            raise
           end
         else
           return_value = symbolic_caller.eval
-          check = check_return(receiver_value:, return_value:, method_type: @method_type)
+          check = check_return(receiver_value:, return_value:)
         end
-        if check
-          stats.success += 1
+        case check
+        in [:success]
           Result::Success.new(symbolic_call:, return_value:)
-        else
+        in [:failure]
           Result::Failure.new(symbolic_call:, return_value:)
+        in [:exception, exception]
+          Result::Exception.new(symbolic_call:, exception:)
         end
       rescue TypeError => exception
         Result::Failure.new(symbolic_call:, return_value:, exception:)
       end
 
     # not ensure symbolic_call
-    rescue NoMethodError => exception
-      stats.skip += 1
+    rescue NoMethodError, NotImplementedError => exception
       Result::Skip.new(symbolic_call:, exception:)
     rescue NameError => e
+      RaaP.logger.error("[#{e.class}] #{e.detailed_message}")
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
-      RaaP.logger.error("Implementation is not found #{msg} maybe.")
+      RaaP.logger.warn("Implementation is not found #{msg} maybe.")
+      RaaP.logger.debug(e.backtrace&.join("\n"))
+      stats.break = true
       throw :break
-    rescue NotImplementedError => exception
-      stats.skip += 1
-      Result::Skip.new(symbolic_call:, exception:)
     rescue SystemStackError => exception
-      stats.skip += 1
-      RaaP.logger.warn "Found recursive type definition."
+      RaaP.logger.info "Found recursive type definition."
       Result::Skip.new(symbolic_call:, exception:)
     rescue => exception
-      stats.exception += 1
       Result::Exception.new(symbolic_call:, exception:)
     end
 
-    def check_return(receiver_value:, return_value:, method_type:)
+    def check_return(receiver_value:, return_value:)
       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
+          if receiver_value == return_value
+            [:success]
+          else
+            [:failure]
+          end
         end
+
         self_class = receiver_value
         instance_class = receiver_value
       else
@@ -98,18 +126,22 @@ module RaaP
         instance_class = BindCall.class(receiver_value)
       end
       type_check = ::RBS::Test::TypeCheck.new(
-        self_class: self_class,
-        instance_class: instance_class,
+        self_class:,
+        instance_class:,
         class_class: Module,
         builder: RBS.builder,
         sample_size: 100,
         unchecked_classes: []
       )
       begin
-        type_check.value(return_value, return_type)
+        if type_check.value(return_value, return_type)
+          [:success]
+        else
+          [:failure]
+        end
       rescue => e
-        $stderr.puts "Type check fail by `(#{e.class}) #{e.message}`"
-        false
+        RaaP.logger.debug("Type check fail by `(#{e.class}) #{e.message}`")
+        [:exception, e]
       end
     end
 

data/lib/raap/method_type.rb

@@ -16,25 +16,32 @@ module RaaP
         else
           raise "bad method #{method}"
         end
-      ts = TypeSubstitution.new(type_params_decl + rbs.type_params, type_args)
+
+      params = (type_params_decl + rbs.type_params).uniq
+      ts = TypeSubstitution.new(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:)
+    def pick_arguments(size: 10)
+      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
+    end
+
+    def arguments_to_symbolic_call(size: 10)
+      args, kwargs = @fun_type.arguments_to_symbolic_call(size:)
+      block = pick_block(size:)
 
       [args, kwargs, block]
     end
 
-    def pick_block(size: 10, eval: true)
+    def pick_block(size: 10)
       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:) }
+      fixed_return_value = Type.new(block.type.return_type).pick(size:)
+      Proc.new { fixed_return_value }
     end
 
     def check_return(return_value)

data/lib/raap/minitest.rb

@@ -11,9 +11,13 @@ module RaaP
         method_type = RaaP::MethodType.new(type)
         size_step.each do |size|
           # TODO assert_send_type
-          args, kwargs, _block = method_type.pick_arguments(size: size)
+          args, kwargs, _block = method_type.pick_arguments(size:)
           return_value = yield(*args, **kwargs)
-          assert method_type.check_return(return_value), "return value: #{BindCall.inspect(return_value)}[#{BindCall.class(return_value)}] is not match with `#{method_type.rbs.type.return_type}`"
+          i = BindCall.inspect(return_value)
+          c = BindCall.class(return_value)
+          r = method_type.rbs.type.return_type
+          msg = "return value: #{i}[#{c}] is not match with `#{r}`"
+          assert method_type.check_return(return_value), msg
         end
       else
         # forall("Integer", "String") { |int, str| Foo.new.int_str(int, str) }
@@ -24,7 +28,7 @@ module RaaP
           end
         end
         size_step.each do |size|
-          values = types.map { |type| type.pick(size: size) }
+          values = types.map { |t| t.pick(size:) }
           assert yield(*values)
         end
       end

data/lib/raap/rbs.rb

@@ -19,5 +19,24 @@ module RaaP
 
       ::RBS::Parser.parse_type(type, require_eof: true) or raise
     end
+
+    def self.parse_method_type(method_type)
+      raise ArgumentError, "empty method type" if method_type == ""
+
+      ::RBS::Parser.parse_method_type(method_type, require_eof: true) or raise
+    end
+
+    def self.find_alias_decl(type_name, method_name)
+      env.class_decls[type_name].decls.each do |d|
+        d.decl.members.each do |member|
+          case member
+          when ::RBS::AST::Members::Alias
+            return member if member.new_name == method_name
+          end
+        end
+      end
+
+      nil
+    end
   end
 end

data/lib/raap/result.rb

@@ -2,22 +2,98 @@
 
 module RaaP
   module Result
-    module CalledStr
+    module ReturnValueWithType
+      def return_value_with_type
+        return_type = return_value_to_type(return_value)
+        type = if return_type.empty? || return_type == 'nil'
+                 ''
+               else
+                 "[#{return_type}]"
+               end
+        "#{BindCall.inspect(return_value)}#{type}"
+      end
+
+      private
+
+      def return_value_to_type(val)
+        case val
+        when nil
+          'nil'
+        when true, false
+          "bool"
+        when Array
+          elem = if val.empty?
+                   'untyped'
+                 else
+                   return_value_to_type(val.first)
+                 end
+          "Array[#{elem}]"
+        when Hash
+          key = val.empty? ? 'untyped' : return_value_to_type(val.keys.first)
+          value = val.empty? ? 'untyped' : return_value_to_type(val.values.first)
+          "Hash[#{key}, #{value}]"
+        when Enumerator
+          elem =
+            begin
+              return_value_to_type(val.peek)
+            rescue StandardError
+              'untyped'
+            end
+          ret =
+            if val.size == Float::INFINITY
+              'bot'
+            else
+              begin
+                val.each {}
+                   .tap { val.rewind }
+                   .then { return_value_to_type(_1) }
+              rescue StandardError
+                'untyped'
+              end
+            end
+          "Enumerator[#{elem}, #{ret}]"
+        else
+          "#{BindCall.class(val)}"
+        end
+      rescue StandardError => e
+        RaaP.logger.debug("[#{e.class}] #{e.exception.detailed_message}")
+        RaaP.logger.debug(e.exception.backtrace&.join("\n"))
+        "raised #{e.class} with check return_type"
+      end
+    end
+
+    class Success < Data.define(:symbolic_call, :return_value)
+      include ReturnValueWithType
+
       def called_str
         scr = SymbolicCaller.new(symbolic_call)
-        "#{scr.call_str} -> #{return_value.inspect}[#{return_value.class}]"
+        "#{scr.call_str} -> #{return_value_with_type}"
       end
     end
 
-    Success = Data.define(:symbolic_call, :return_value)
-    Success.include CalledStr
-    Failure = Data.define(:symbolic_call, :return_value, :exception) do
+    class Failure < Data.define(:symbolic_call, :return_value, :exception)
+      include ReturnValueWithType
+
       def initialize(exception: nil, **)
         super
       end
+
+      def called_str
+        scr = SymbolicCaller.new(symbolic_call)
+        return_type =
+          if exception
+            "raised #{exception.class}"
+          else
+            return_value_with_type
+          end
+        "#{scr.call_str} -> #{return_type}"
+      end
+    end
+
+    class Skip < Data.define(:symbolic_call, :exception)
+    end
+
+    class Exception < Data.define(:symbolic_call, :exception)
     end
-    Failure.include CalledStr
-    Skip = Data.define(:symbolic_call, :exception)
-    Exception = Data.define(:symbolic_call, :exception)
   end
 end

data/lib/raap/sized.rb

@@ -4,6 +4,7 @@ module RaaP
   class Sized
     def initialize(&block)
       raise LocalJumpError, "no block given" unless block
+
       @block = block
       @such_that = nil
     end
@@ -28,6 +29,7 @@ module RaaP
         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

data/lib/raap/symbolic_caller.rb

@@ -18,6 +18,7 @@ module RaaP
   class SymbolicCaller
     class Var
       attr_reader :name
+
       def initialize(name)
         @name = name
       end
@@ -46,13 +47,13 @@ module RaaP
     end
 
     def call_str
-      symbolic_call => [:call, receiver, Symbol => method_name, Array => args, Hash => kwargs, b]
+      symbolic_call => [:call, receiver, Symbol => method_name, Array => args, Hash => kwargs, block]
       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?
+      a << args.map(&BindCall.method(: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
 
@@ -61,7 +62,7 @@ module RaaP
 
     def to_lines
       [].tap do |lines|
-        walk do |symbolic_call|
+        walk do |symbolic_call, is_last|
           symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
 
           is_mod = receiver_value.is_a?(Module)
@@ -72,7 +73,7 @@ module RaaP
             var_eq = "#{var} = "
             receiver = ''
           when BindCall.instance_of?(receiver_value, Var)
-            var_eq = ""
+            var_eq = "#{receiver_value} = "
             var = Var.new(receiver_value.name)
             receiver = var + '.'
           when is_mod
@@ -80,16 +81,32 @@ module RaaP
             var_eq = "#{var} = "
             receiver = receiver_value.name + '.'
           else
-            var_eq = ""
+            var_eq = ''
             receiver = Var.new(printable(receiver_value)) + '.'
           end
 
+          var_eq = '' if is_last
+
           arguments = []
-          arguments << args.map { |a| printable(a) } if !args.empty?
-          arguments << kwargs.map{|k,v| "#{k}: #{printable(v)}" }.join(', ') if !kwargs.empty?
+          if !args.empty?
+            # The reproduction code is kept short and executable.
+            if [Value::Interface, Value::Intersection].include?(receiver_value)
+              if args.all? { |a| a.respond_to?(:free_variables) } && !args.all? { |a| a.free_variables.empty? }
+                # FIXME: Type arguments are not yet supported.
+                args.each do |a|
+                  lines << "# Free variables: #{a.free_variables.to_a.join(', ')}"
+                end
+              end
+              arguments << args.map { |a| printable(a.to_s) }
+            else
+              arguments << args.map { |a| printable(a) }
+            end
+          end
+          arguments << kwargs.map { |k, v| "#{k}: #{printable(v)}" }.join(', ') if !kwargs.empty?
           block_str = block ? " { }" : ""
 
-          lines << "#{var_eq}#{receiver}#{method_name}(#{arguments.join(', ')})#{block_str}"
+          line = "#{var_eq}#{receiver}#{method_name}(#{arguments.join(', ')})#{block_str}"
+          lines << line
 
           var
         end
@@ -105,25 +122,24 @@ module RaaP
     end
 
     def walk(&)
-      _walk(@symbolic_call, &)
+      _walk(@symbolic_call, true, &)
     end
 
-    def _walk(symbolic_call, &block)
+    def _walk(symbolic_call, is_last, &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 Var
-        symbolic_call.name
+        receiver = _walk(receiver, false, &block)
+        args = _walk(args, false, &block) if !args.empty?
+        kwargs = _walk(kwargs, false, &block) if !kwargs.empty?
+        block.call [:call, receiver, method_name, args, kwargs, b], is_last
       in Array
-        symbolic_call.map { |sc| _walk(sc, &block) }
+        symbolic_call.map { |sc| _walk(sc, false, &block) }
       in Hash
-        symbolic_call.transform_values { |sc| _walk(sc, &block) }
+        symbolic_call.transform_keys { |k| _walk(k, false, &block) }
+                     .transform_values! { |v| _walk(v, false, &block) }
       else
         symbolic_call
       end
@@ -143,15 +159,11 @@ module RaaP
     end
 
     def printable(obj)
-      if obj in [:call, _, Symbol, Array, Hash, _]
-        return _walk(obj)
-      end
-
       case obj
       when Var
         obj.name
       # Object from which it can get strings that can be eval with `#inspect`
-      when Symbol, Integer, Float, Regexp, nil, true, false
+      when Symbol, Integer, Float, Regexp, Range, nil, true, false
         obj.inspect
       when String
         obj.inspect.gsub('"', "'") or raise
@@ -165,9 +177,9 @@ module RaaP
       when Array
         "[#{obj.map { |o| printable(o) }.join(', ')}]"
       when Module
-        BindCall.name(obj) or raise
+        BindCall.name(obj) or raise "`#class` method returns nil"
       else
-        var_name(obj.class)
+        var_name(BindCall.class(obj))
       end
     end
   end