raap 0.3.0 → 0.5.0

data/lib/raap/type.rb

@@ -13,25 +13,61 @@ module RaaP
 
       def self.positive_float
         x = Random.rand
-        x / Math.sqrt(1 - x * x)
+        x / Math.sqrt(1 - (x * x))
       end
     end
 
     GENERATORS = {}
     SIMPLE_SOURCE = ('a'..'z').to_a << '_'
-    RECURSION = Hash.new { |h, k| h[k] = { count: 0, logged: false } }
 
     # Type.register "::Integer::positive" { sized { |size| size } }
     def self.register(type_name, &block)
       raise ArgumentError, "block is required" unless block
+
       GENERATORS[type_name] = __skip__ = block
     end
 
+    def self.random
+      Type.new("Integer | Float | Rational | Complex | String | Symbol | bool | Encoding | BasicObject | nil | Time")
+    end
+
+    def self.random_without_basic_object
+      random.tap do |r|
+        # @type var rtype: ::RBS::Types::Union
+        rtype = r.type
+        rtype.types.reject! { |t| t.to_s == "BasicObject" }
+      end
+    end
+
+    def self.call_new_from(base, type, size:)
+      type_name = type.name.absolute!
+      definition = RBS.builder.build_singleton(type_name)
+      snew = definition.methods[:new]
+      if snew
+        # class
+        rbs_method_type = snew.method_types.sample or raise
+        type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
+        ts = TypeSubstitution.new(type_params, type.args)
+        maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
+        method_type = MethodType.new(maped_rbs_method_type)
+
+        begin
+          args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
+          [:call, base, :new, args, kwargs, block]
+        rescue
+          $stderr.puts "Fail with `#{rbs_method_type}`"
+          raise
+        end
+      else
+        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
+      end
+    end
+
     # Special class case
     register("::Array") do
-      _type = __skip__ = type
-      t = _type.args[0] || 'untyped'
-      array(Type.new(t, range: range))
+      instance = __skip__ = type
+      t = instance.args[0] ? Type.new(instance.args[0], range:) : Type.random
+      array(t)
     end
     register("::Binding") { sized { binding } }
     register("::Complex") { complex }
@@ -40,14 +76,10 @@ module RaaP
     register("::FalseClass") { sized { false } }
     register("::Float") { float }
     register("::Hash") do
-      sized do |size|
-        Array.new(integer.pick(size: size).abs).to_h do
-          _type = __skip__ = type
-          k = _type.args[0] || 'untyped'
-          v = _type.args[1] || 'untyped'
-          [Type.new(k).pick(size: size), Type.new(v).pick(size: size)]
-        end
-      end
+      instance = __skip__ = type
+      key = instance.args[0] ? Type.new(instance.args[0]) : Type.random_without_basic_object
+      value = instance.args[1] ? Type.new(instance.args[1]) : Type.random
+      dict(key, value)
     end
     register("::Integer") { integer }
     register("::IO") { sized { $stdout } }
@@ -55,11 +87,11 @@ module RaaP
     register("::NilClass") { sized { nil } }
     register("::Proc") { sized { Proc.new {} } }
     register("::Rational") { rational }
-    register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
+    register("::Regexp") { sized { |size| Regexp.new(string.pick(size:)) } }
     register("::String") { string }
     register("::Struct") { sized { Struct.new(:foo, :bar).new } }
     register("::Symbol") { symbol }
-    register("::Time") { sized { Time.now } }
+    register("::Time") { sized { [:call, Time, :now, [], {}, nil] } }
     register("::TrueClass") { sized { true } }
     register("::UnboundMethod") { sized { temp_method_object.unbind } }
 
@@ -79,15 +111,18 @@ module RaaP
 
     def sized(&block)
       Sized.new(&block).tap do |sized|
-        if s = @such_that
+        if (s = @such_that)
           sized.such_that(&s)
         end
       end
     end
 
-    def pick(size: 10, eval: true)
-      symb = to_symbolic_call(size:)
-      eval ? SymbolicCaller.new(symb).eval : symb
+    def pick(size: 10)
+      to_symbolic_caller(size:).eval
+    end
+
+    def to_symbolic_caller(size: 10)
+      SymbolicCaller.new(to_symbolic_call(size:))
     end
 
     def to_symbolic_call(size: 10)
@@ -96,15 +131,23 @@ module RaaP
 
       case type
       when ::RBS::Types::Tuple
-        type.types.map { |t| Type.new(t).pick(size:) }
+        type.types.map { |t| Type.new(t).to_symbolic_call(size:) }
       when ::RBS::Types::Union
-        type.types.sample&.then { |t| Type.new(t).pick(size:) }
+        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size:) }
       when ::RBS::Types::Intersection
-        [:call, Value::Intersection, :new, [type], {size:}, nil]
+        if type.free_variables.empty?
+          [:call, Value::Intersection, :new, [type.to_s], { size: }, nil]
+        else
+          [:call, Value::Intersection, :new, [type], { size: }, nil]
+        end
       when ::RBS::Types::Interface
-        [:call, Value::Interface, :new, [type], {size:}, nil]
+        if type.free_variables.empty?
+          [:call, Value::Interface, :new, [type.to_s], { size: }, nil]
+        else
+          [:call, Value::Interface, :new, [type], { size: }, nil]
+        end
       when ::RBS::Types::Variable
-        [:call, Value::Variable, :new, [type], {}, nil]
+        [:call, Value::Variable, :new, [type.to_s], {}, nil]
       when ::RBS::Types::Bases::Void
         [:call, Value::Void, :new, [], {}, nil]
       when ::RBS::Types::Bases::Top
@@ -113,72 +156,52 @@ module RaaP
         [:call, Value::Bottom, :new, [], {}, nil]
       when ::RBS::Types::Optional
         case Random.rand(2)
-        in 0 then Type.new(type.type).pick(size:)
+        in 0 then Type.new(type.type).to_symbolic_call(size: size / 2)
         in 1 then nil
         end
       when ::RBS::Types::Alias
         case gen = GENERATORS[type.name.absolute!.to_s]
         in Proc then instance_exec(&gen)
-        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).pick(size:)
+        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size:)
         end
       when ::RBS::Types::Bases::Class
-        raise "cannot resolve `class` type"
+        RaaP.logger.warn("Unresolved `class` type, use Object instead.")
+        Object
       when ::RBS::Types::Bases::Instance
-        raise "cannot resolve `instance` type"
+        RaaP.logger.warn("Unresolved `instance` type, use Object.new instead.")
+        Object.new
       when ::RBS::Types::Bases::Self
         raise "cannot resolve `self` type"
       when ::RBS::Types::ClassSingleton
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
         case gen = GENERATORS[type.name.absolute!.to_s]
-        in Proc then instance_exec(&gen).pick(size: size)
-        in nil then pick_from_initialize(type, size:)
+        in Proc then instance_exec(&gen).pick(size:)
+        in nil then to_symbolic_call_from_initialize(type, size:)
         end
       when ::RBS::Types::Record
-        type.fields.transform_values { |t| Type.new(t).pick(size:) }
+        type.fields.transform_values { |t| Type.new(t).to_symbolic_call(size: size / 2) }
       when ::RBS::Types::Proc
-        Proc.new { Type.new(type.type.return_type).pick(size:) }
+        Proc.new { Type.new(type.type.return_type).to_symbolic_call(size:) }
       when ::RBS::Types::Literal
         type.literal
       when ::RBS::Types::Bases::Bool
-        bool.pick(size: size)
+        bool.pick(size:)
       when ::RBS::Types::Bases::Any
-        untyped.pick(size: size)
+        Type.random.to_symbolic_call(size:)
       when ::RBS::Types::Bases::Nil
         nil
       else
-        raise "not implemented #{type.to_s}"
+        raise "not implemented #{type}"
       end
     end
 
     private
 
-    def pick_from_initialize(type, size:)
+    def to_symbolic_call_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
-      definition = RBS.builder.build_singleton(type_name)
-      snew = definition.methods[:new]
-      if snew
-        # class
-        rbs_method_type = snew.method_types.sample or raise
-        type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
-        ts = TypeSubstitution.new(type_params, type.args)
-        maped_rbs_method_type = rbs_method_type
-        maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
-        method_type = MethodType.new(maped_rbs_method_type)
-
-        begin
-          try(times: 5, size: size) do |size|
-            args, kwargs, block = method_type.pick_arguments(size: size, eval: false)
-            [:call, const, :new, args, kwargs, block]
-          end
-        rescue
-          $stderr.puts "Fail with `#{rbs_method_type}`"
-          raise
-        end
-      else
-        [:call, Value::Module, :new, [type], {}, nil]
-      end
+      Type.call_new_from(const, type, size:)
     end
 
     def parse(type)
@@ -192,33 +215,8 @@ module RaaP
       end
     end
 
-    def try(times:, size:)
-      # @type var error: Exception?
-      ret = error = nil
-      times.times do
-        ret = yield size
-        if ret
-          error = nil
-          break
-        end
-      rescue => e
-        size += 1
-        error = e
-        next
-      end
-
-      if error
-        $stderr.puts
-        $stderr.puts "=== Catch error when generating type `#{type}`. Please check your RBS or RaaP bug. ==="
-        $stderr.puts "(#{error.class}) #{error.message}"
-        raise error
-      end
-
-      ret
-    end
-
     def integer
-      sized { |size| float.pick(size: size).round }
+      sized { |size| float.pick(size:).round }
     end
 
     def none_zero_integer
@@ -231,9 +229,9 @@ module RaaP
         in nil, nil
           Arithmetic.float * size
         in nil, high
-          high - Arithmetic.positive_float * size
+          high - (Arithmetic.positive_float * size)
         in low, nil
-          low + Arithmetic.positive_float * size
+          low + (Arithmetic.positive_float * size)
         in low, high
           Random.rand(Range.new(low.to_f, high.to_f, @range.exclude_end?))
         end.round(2)
@@ -242,16 +240,16 @@ module RaaP
 
     def rational
       sized do |size|
-        a = integer.pick(size: size)
-        b = none_zero_integer.pick(size: size)
+        a = integer.pick(size:)
+        b = none_zero_integer.pick(size:)
         [:call, Kernel, :Rational, [a, b], {}, nil]
       end
     end
 
     def complex
       sized do |size|
-        a = integer.pick(size: size)
-        b = none_zero_integer.pick(size: size)
+        a = integer.pick(size:)
+        b = none_zero_integer.pick(size:)
         [:call, Kernel, :Complex, [a, b], {}, nil]
       end
     end
@@ -262,13 +260,11 @@ module RaaP
           +""
         else
           case [@range.begin, @range.end]
-          in nil, nil
+          in [nil, nil]
             size.times.map { SIMPLE_SOURCE.sample }.join
-          in nil, _
-            raise "Should set range.begin and range.end"
-          in _, nil
+          in [nil, _] | [_, nil]
             raise "Should set range.begin and range.end"
-          in s, e
+          in [s, e]
             a = (s..e).to_a
             size.times.map { a.sample }.join
           end
@@ -278,14 +274,28 @@ module RaaP
 
     def symbol
       sized do |size|
-        string.pick(size: size).to_sym
+        string.pick(size:).to_sym
       end
     end
 
     def array(type)
       sized do |size|
-        Array.new(integer.pick(size: size).abs) do
-          type.pick(size: size)
+        Array.new(integer.pick(size:).abs) do
+          type.to_symbolic_call(size: size / 2)
+        end
+      end
+    end
+
+    # Create Hash object. But not `hash`.
+    # Avoid to use `hash` since core method name
+    def dict(key_type, value_type)
+      sized do |size|
+        csize = size / 2
+        Array.new(integer.pick(size:).abs).to_h do
+          [
+            key_type.to_symbolic_call(size: csize),
+            value_type.to_symbolic_call(size: csize)
+          ]
         end
       end
     end
@@ -293,7 +303,7 @@ module RaaP
     def encoding
       sized do
         e = Encoding.list.sample or raise
-        [:call, Encoding, :find, [e.name], {} , nil]
+        [:call, Encoding, :find, [e.name], {}, nil]
       end
     end
 
@@ -303,24 +313,10 @@ module RaaP
       end
     end
 
-    def untyped
-      case Random.rand(9)
-      in 0 then integer
-      in 1 then float
-      in 2 then rational
-      in 3 then complex
-      in 4 then string
-      in 5 then symbol
-      in 6 then bool
-      in 7 then encoding
-      in 8 then sized { [:call, BasicObject, :new, [], {}, nil] }
-      end
-    end
-
     def temp_method_object
       o = Object.new
       m = 6.times.map { SIMPLE_SOURCE.sample }.join
-      o.define_singleton_method(m) { }
+      o.define_singleton_method(m) {}
       o.method(m)
     end
   end

data/lib/raap/type_substitution.rb

@@ -14,13 +14,16 @@ module RaaP
         elsif bound.upper_bound
           [bound.name, bound.upper_bound]
         else
-          [bound.name, ::RBS::Types::Bases::Top.new(location: nil)]
+          [bound.name, ::RBS::Types::Variable.new(name: bound.name, location: nil)]
         end
       end
       ::RBS::Substitution.build(bound_map.keys, bound_map.values)
     end
 
     def method_type_sub(method_type, self_type: nil, instance_type: nil, class_type: nil)
+      self_type = self_type.is_a?(::String) ? RBS.parse_type(self_type) : self_type
+      instance_type = instance_type.is_a?(::String) ? RBS.parse_type(instance_type) : instance_type
+      class_type = class_type.is_a?(::String) ? RBS.parse_type(class_type) : class_type
       sub = build
       ::RBS::MethodType.new(
         type_params: [],
@@ -36,6 +39,7 @@ module RaaP
       if self_type.nil? && instance_type.nil? && class_type.nil?
         return search
       end
+
       search.map_type do |ty|
         case ty
         when ::RBS::Types::Bases::Self

data/lib/raap/value/bottom.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     class Bottom < BasicObject

data/lib/raap/value/interface.rb

@@ -3,39 +3,73 @@
 module RaaP
   module Value
     class Interface < BasicObject
-      def initialize(type, size: 3, self_type: nil, instance_type: nil, class_type: nil)
-        @type = type.is_a?(::String) ? RBS.parse_type(type) : type
-        @size = size
+      class << self
+        def define_method_from_interface(base_class, type, size: 3)
+          type = type.is_a?(::String) ? RBS.parse_type(type) : type
+          unless type.instance_of?(::RBS::Types::Interface)
+            ::Kernel.raise ::TypeError, "not an interface type: #{type}"
+          end
+          self_type = type
 
-        definition = RBS.builder.build_interface(@type.name.absolute!)
-        definition.methods.each do |name, method|
-          method_type = method.method_types.sample or Kernel.raise
-          type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
-          ts = TypeSubstitution.new(type_params, @type.args)
+          # Referring to Steep
+          instance_type = ::RBS::Types::ClassInstance.new(name: TypeName("::Object"), args: [], location: nil)
+          class_type = ::RBS::Types::ClassSingleton.new(name: TypeName("::Object"), location: nil)
 
-          subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
+          definition = RBS.builder.build_interface(type.name.absolute!)
+          definition.methods.each do |name, method|
+            method_type = method.method_types.sample or ::Kernel.raise
+            type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
+            ts = TypeSubstitution.new(type_params, type.args)
+            subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
 
-          BindCall.define_singleton_method(self, name) do |*, &b|
-            @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size: size)
-            if subed_method_type.block
-              @fixed_block_arguments ||= size.times.map do
-                fun_type = FunctionType.new(subed_method_type.block.type)
-                fun_type.pick_arguments(size: size)
-              end
-            else
-              @fixed_block_arguments = []
-            end
-            if b
-              unless subed_method_type.block
-                Kernel.raise "block of `#{@type.name}##{name}` was called. But block signature not defined."
-              end
-              @fixed_block_arguments.each do |a, kw|
-                b.call(*a, **kw)
+            BindCall.define_method(base_class, name) do |*_, &b|
+              @fixed_return_value ||= {}
+              @fixed_return_value[name] ||= if self_type == subed_method_type.type.return_type
+                                              self
+                                            else
+                                              Type.new(subed_method_type.type.return_type).pick(size:)
+                                            end
+              # @type var b: Proc?
+              if b
+                @fixed_block_arguments ||= {}
+                @fixed_block_arguments[name] ||= if subed_method_type.block
+                                                   size.times.map do
+                                                     FunctionType.new(subed_method_type.block.type)
+                                                                 .pick_arguments(size:)
+                                                   end
+                                                 else
+                                                   []
+                                                 end
+                @fixed_block_arguments[name].each do |a, kw|
+                  b.call(*a, **kw)
+                end
               end
+              @fixed_return_value[name]
             end
-            @fixed_return_value
           end
         end
+
+        def new(type, size: 3)
+          temp_class = ::Class.new(Interface) do |c|
+            define_method_from_interface(c, type, size:)
+          end
+          instance = temp_class.allocate
+          instance.__send__(:initialize, type, size:)
+          instance
+        end
+      end
+
+      def initialize(type, size: 3)
+        @type = type.is_a?(::String) ? RBS.parse_type(type) : type
+        unless @type.instance_of?(::RBS::Types::Interface)
+          ::Kernel.raise ::TypeError, "not an interface type: #{type}"
+        end
+        @definition = RBS.builder.build_interface(@type.name.absolute!)
+        @size = size
+      end
+
+      def respond_to?(name, _include_all = false)
+        @definition.methods.has_key?(name.to_sym)
       end
 
       def class
@@ -43,7 +77,7 @@ module RaaP
       end
 
       def inspect
-        "#<interface @type=#{@type.to_s} @methods=#{RBS.builder.build_interface(@type.name.absolute!).methods.keys} @size=#{@size}>"
+        "#<interface @type=`#{@type}` @methods=#{@definition.methods.keys} @size=#{@size}>"
       end
     end
   end

data/lib/raap/value/intersection.rb

@@ -2,33 +2,38 @@
 
 module RaaP
   module Value
-    class Intersection < BasicObject
-      def initialize(type, size:)
-        @type = type
-        @children = type.types.map { |t| Type.new(t).pick(size: size) }
-        @size = size
-      end
+    module Intersection
+      # Build an object to realize an intersection.
+      def self.new(type, size: 3)
+        type = type.is_a?(::String) ? RBS.parse_type(type) : type
+        unless type.instance_of?(::RBS::Types::Intersection)
+          ::Kernel.raise ::TypeError, "not an intersection type: #{type}"
+        end
+        instances = type.types.filter_map do |t|
+          t.instance_of?(::RBS::Types::ClassInstance) && Object.const_get(t.name.absolute!.to_s)
+        end
+        instances.uniq!
+        unless instances.count { |c| c.is_a?(::Class) } <= 1
+          raise ArgumentError, "intersection type must have at least one class instance type in `#{instances}`"
+        end
 
-      def inspect
-        "#<intersection @type=#{@type.to_s.inspect} @size=#{@size.inspect}>"
-      end
+        base = instances.find { |c| c.is_a?(::Class) } || BasicObject
 
-      def class
-        Intersection
-      end
+        c = Class.new(base) do
+          instances.select { |i| !i.is_a?(::Class) }.each do |m|
+            include(m)
+          end
 
-      def method_missing(name, *args, **kwargs, &block)
-        @children.each do |child|
-          if BindCall.respond_to?(child, name)
-            return child.__send__(name, *args, **kwargs, &block)
+          interfaces = type.types.select do |t|
+            t.instance_of?(::RBS::Types::Interface)
           end
-        end
-      end
 
-      def respond_to?(...)
-        @children.any? do |type|
-          BindCall.respond_to?(type, ...)
+          interfaces.each do |interface|
+            Interface.define_method_from_interface(self, interface, size:)
+          end
         end
+        type = ::RBS::Types::ClassInstance.new(name: TypeName(base.name), args: [], location: nil)
+        SymbolicCaller.new(Type.call_new_from(c, type, size:)).eval
       end
     end
   end

data/lib/raap/value/module.rb

@@ -1,17 +1,60 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     # FIXME: consider self_types
     # HINT: intersection?
-    class Module
-      attr_reader :type
+    class Module < BasicObject
+      def initialize(type, size: 3)
+        @type = type.is_a?(::String) ? ::RaaP::RBS.parse_type(type) : type
+        @size = size
+        unless @type.instance_of?(::RBS::Types::ClassInstance)
+          ::Kernel.raise ::TypeError, "not a module type: #{@type}"
+        end
+
+        one_instance_ancestors = ::RaaP::RBS.builder.ancestor_builder.one_instance_ancestors(@type.name.absolute!).self_types
+        @self_type = if one_instance_ancestors.nil? || one_instance_ancestors.empty?
+                       ::Object.new
+                     else
+                       one_instance_ancestors.map do |a_instance|
+                         if a_instance.args.empty?
+                           # : BasicObject
+                           a_instance.name.absolute!.to_s
+                         else
+                           # : _Each[Integer]
+                           args = a_instance.args.zip(@type.args).map do |_var, instance|
+                             if instance
+                               instance.to_s
+                             else
+                               'untyped'
+                             end
+                           end
+                           "#{a_instance.name}[#{args.map(&:to_s).join(', ')}]"
+                         end
+                       end.then do |ts|
+                         if !ts.include?('::BasicObject') || ts.any? { |t| t.split('::').last&.start_with?('_') }
+                           ts.unshift('Object')
+                         end
+                         Type.new(ts.uniq.join(' & ')).pick(size:)
+                       end
+                     end
+        const = ::Object.const_get(@type.name.absolute!.to_s)
+        BindCall.extend(self, const)
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        @self_type.__send__(name, *args, **kwargs, &block)
+      end
 
-      def initialize(type)
-        @type = type
-        const = ::Object.const_get(type.name.absolute!.to_s)
-        extend(const)
+      def respond_to?(name, include_all = false)
+        if BindCall.instance_of?(@self_type, ::BasicObject)
+          BindCall.respond_to?(@self_type, name, include_all)
+        else
+          @self_type.respond_to?(name, include_all)
+        end
       end
 
-      def inspect = "#<module #{@type}>"
+      def inspect = "#<module #{@type} : #{BindCall.class(@self_type)} size=#{@size}>"
       def class = Value::Module
     end
   end

data/lib/raap/value/top.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     class Top < BasicObject