raap 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 312e27904176673d6962904901cb3e8d31c6b613b8efdf669c877d4670cf9d15
-  data.tar.gz: fe940b9d2928a54bfbba8a4842c097cb2a8efe6cf0b873baa383f757de37d017
+  metadata.gz: 5780226ede8755c1ef7f82e18b7e8d96a63d2ab6eb253bc8964f5745776f993f
+  data.tar.gz: 6e9dd39a302f555cac12ecb6232a7c2f39d206911fcee7a30650d5fe4a9cbc63
 SHA512:
-  metadata.gz: 55070cb0335ae161e3a1f6e62d9faa9d205e0b1c92186d2e81eaea2547d476d092fa90a9c6607d2d4ad11cf1f0a0bab723539e90cc4932d49bc297e069e07632
-  data.tar.gz: 771e2f640454bfcd8774ccc0d1ac3079df7e6f1edb7d209327881fea2febb6bbfe04af937481e3e6d81bf9b05046860fc7d861af38b523872d1af8d62a0717da
+  metadata.gz: 2841e75bc0b03742cc0d9268f9ec2ae69f2f9c6e1f579ec6e794db5e9b8f80d763fac4ce28abd7361e19ada8f6289e594b6a9a3cdc63b1806181a69a9f49bb6a
+  data.tar.gz: a3057811c5d13ac4f891fc2c2082b91f33a1a8d35d3c9b6e1ccb1871c268127811caa6f2708c878ef35ae4cc25143db62c4e5801ded32cfad9a1db50387753a6

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.3
+  TargetRubyVersion: 3.0
   NewCops: enable
   Include:
   - 'lib/**/*.rb'
@@ -14,6 +14,8 @@ Style:
 Style/HashSyntax:
   EnforcedShorthandSyntax: always
   Enabled: true
+Style/FrozenStringLiteralComment:
+  Enabled: true
 
 Metrics:
   Enabled: false

data/README.md

@@ -1,6 +1,6 @@
 # RaaP
 
-![Jacket](https://raw.githubusercontent.com/ksss/raap/main/public/DALL%C2%B7E%202024-03-23%2000.02.29%20-%20Imagine%20a%20scene%20where%20the%20abstract%20concepts%20of%20Ruby%20programming%20and%20property-based%20testing%20blend%20harmoniously.%20Picture%20a%20large%2C%20glowing%20ruby%20crystal%2C%20.webp)
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=400/>
 
 ## RBS as a Property
 
@@ -70,8 +70,24 @@ $ raap 'MyClass'                  # Run only RBS of MyClass
 $ raap 'MyClass::*'               # Run each class under MyClass
 $ raap 'MyClass.singleton_method' # Run only MyClass.singleton_method
 $ raap 'MyClass#instance_method'  # Run only MyClass#instance_method
+$ raap 'MyClass' '!MyClass#skip'  # Run methods MyClass without #skip
 ```
 
+```
+$ cat test/raap.txt
+MyClass
+!MyClass#skip
+
+$ raap $(cat test/raap.txt)   # You can manage the methods to be tested in a file
+```
+
+## Log level definition
+
+- error: Information on status of inability to continue execution.
+- warn: Information on partial corrections required.
+- info: A somewhat visualized representation of the execution state.
+- debug: All information including stack traces.
+
 ## Size
 
 Random values are determined based on size.
@@ -103,11 +119,15 @@ You can specify to load specify PATH as RBS.
 
 ### `--library lib`
 
-You can specify to load RBS library
+You can specify to load RBS library.
 
 ### `--require lib`
 
-You can specify require Ruby library
+You can specify require Ruby library.
+
+### `--log-level level`
+
+You can specify log level (debug, info, warn or error).
 
 ### `--timeout sec`
 
@@ -125,6 +145,11 @@ You can specify size of end.
 
 You can specify size of step like `Integer#step: (to: Integer, by: Integer)`.
 
+### `--allow-private`
+
+By default, raap only validates public methods.
+However, by setting this option, it is possible to intentionally validate private methods in the RBS.
+
 ## First support is CLI
 
 In RaaP, usage through the CLI is the primary support focus, and efforts are made to maintain compatibility. The use of the library's code (such as `RaaP::Type`) does not guarantee compatibility.

data/Rakefile

@@ -4,7 +4,9 @@ require "bundler/gem_tasks"
 require "minitest/test_task"
 require "rubocop/rake_task"
 
-Minitest::TestTask.create
+Minitest::TestTask.create do |t|
+  t.test_prelude = 'require "test/test_helper"'
+end
 
 RuboCop::RakeTask.new
 

data/exe/raap

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'raap'
 

data/lib/raap/bind_call.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module RaaP
   module BindCall
     class << self
-      def define_singleton_method(...) = ::Object.instance_method(:define_singleton_method).bind_call(...)
+      def define_method(...) = ::Module.instance_method(:define_method).bind_call(...)
       def respond_to?(...) = ::Kernel.instance_method(:respond_to?).bind_call(...)
       def instance_of?(...) = ::Kernel.instance_method(:instance_of?).bind_call(...)
       def is_a?(...) = ::Kernel.instance_method(:is_a?).bind_call(...)

data/lib/raap/cli.rb

@@ -12,7 +12,6 @@ module RaaP
       :size_to,
       :size_by,
       :allow_private,
-      :skips,
       keyword_init: true
     )
 
@@ -45,7 +44,6 @@ module RaaP
         size_from: 0,
         size_to: 99,
         size_by: 1,
-        skips: [],
         allow_private: false,
       )
       @argv = argv
@@ -64,7 +62,7 @@ module RaaP
         o.on('--require lib', 'require ruby library') do |lib|
           @option.requires << lib
         end
-        o.on('--log-level level', "default: warn") do |arg|
+        o.on('--log-level level', "default: info") do |arg|
           RaaP.logger.level = arg
         end
         o.on('--timeout sec', Float, "default: #{@option.timeout}") do |arg|
@@ -82,9 +80,6 @@ module RaaP
         o.on('--allow-private', "default: #{@option.allow_private}") do
           @option.allow_private = true
         end
-        o.on('--skip tag', "skip case (e.g. `Foo#meth`)") do |tag|
-          @option.skips << tag
-        end
       end.parse!(@argv)
 
       @option.dirs.each do |dir|
@@ -96,10 +91,6 @@ module RaaP
       @option.requires.each do |lib|
         require lib
       end
-      @option.skips.each do |skip|
-        @skip << skip
-      end
-      @skip.freeze
 
       self
     end
@@ -111,16 +102,29 @@ module RaaP
         exit 1
       end
 
-      @argv.map do |tag|
+      # Search skip tag
+      @argv.each do |tag|
+        if tag.start_with?('!')
+          t = tag[1..] or raise
+          t = "::#{t}" unless t.start_with?('::')
+          t or raise
+          @skip << t
+        end
+      end
+      @skip.freeze
+
+      @argv.each do |tag|
+        next if tag.start_with?('!')
+
         case
         when tag.include?('#')
-          run_by(kind: :instance, tag:)
+          run_by(kind: :instance, tag: tag)
         when tag.include?('.')
-          run_by(kind: :singleton, tag:)
+          run_by(kind: :singleton, tag: tag)
         when tag.end_with?('*')
-          run_by_type_name_with_search(tag:)
+          run_by_type_name_with_search(tag: tag)
         else
-          run_by_type_name(tag:)
+          run_by_type_name(tag: tag)
         end
       end
 
@@ -194,9 +198,10 @@ module RaaP
 
       RaaP.logger.info("# #{type}")
       @results << {
-        method:,
+        method: method,
         properties: method.method_types.map do |method_type|
-          property(receiver_type:, type_params_decl:, type_args:, method_type:, method_name:)
+          property(receiver_type: receiver_type, type_params_decl: type_params_decl, type_args: type_args, method_type: method_type,
+                   method_name: method_name)
         end
       }
     end
@@ -204,7 +209,11 @@ module RaaP
     def run_by_type_name_with_search(tag:)
       first, _last = tag.split('::')
       RBS.env.class_decls.each do |name, _entry|
-        if ['', '::'].any? { |pre| name.to_s.match?(/\A#{pre}#{first}\b/) }
+        if ['', '::'].any? { |pre| name.to_s.start_with?("#{pre}#{first}") }
+          if @skip.include?(name.to_s)
+            RaaP.logger.info("Skip #{name}")
+            next
+          end
           run_by_type_name(tag: name.to_s)
         end
       end
@@ -220,32 +229,40 @@ module RaaP
 
       definition = RBS.builder.build_singleton(type_name)
       type_params_decl = definition.type_params_decl
-      definition.methods.filter_map do |method_name, method|
-        next if @skip.include?("#{type_name.absolute!}.#{method_name}")
+      definition.methods.each do |method_name, method|
+        if @skip.include?("#{type_name.absolute!}.#{method_name}")
+          RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
+          next
+        end
         next unless method.accessibility == :public
         next if method.defined_in != type_name
 
         RaaP.logger.info("# #{type_name}.#{method_name}")
         @results << {
-          method:,
+          method: method,
           properties: method.method_types.map do |method_type|
-            property(receiver_type: Type.new("singleton(#{type.name})"), type_params_decl:, type_args:, method_type:, method_name:)
+            property(receiver_type: Type.new("singleton(#{type.name})"), type_params_decl: type_params_decl, type_args: type_args,
+                     method_type: method_type, method_name: method_name)
           end
         }
       end
 
       definition = RBS.builder.build_instance(type_name)
       type_params_decl = definition.type_params_decl
-      definition.methods.filter_map do |method_name, method|
-        next if @skip.include?("#{type_name.absolute!}##{method_name}")
+      definition.methods.each do |method_name, method|
+        if @skip.include?("#{type_name.absolute!}##{method_name}")
+          RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
+          next
+        end
         next unless method.accessibility == :public
         next if method.defined_in != type_name
 
         RaaP.logger.info("# #{type_name}##{method_name}")
         @results << {
-          method:,
+          method: method,
           properties: method.method_types.map do |method_type|
-            property(receiver_type: Type.new(type.name), type_params_decl:, type_args:, method_type:, method_name:)
+            property(receiver_type: Type.new(type.name), type_params_decl: type_params_decl, type_args: type_args, method_type: method_type,
+                     method_name: method_name)
           end
         }
       end
@@ -258,28 +275,30 @@ module RaaP
       else
         prefix = ''
       end
-      type_params_decl.each_with_index do |_, i|
+
+      # type_args delegate to self_type
+      type_params_decl.each_with_index do |param, i|
         if rtype.instance_of?(::RBS::Types::ClassInstance)
-          rtype.args[i] = type_args[i] || ::RBS::Types::Bases::Any.new(location: nil)
+          rtype.args[i] = type_args[i] || param.upper_bound || ::RBS::Types::Bases::Any.new(location: nil)
         end
       end
       RaaP.logger.info("## def #{prefix}#{method_name}: #{method_type}")
       status = 0
       reason = nil
       prop = MethodProperty.new(
-        receiver_type:,
-        method_name:,
+        receiver_type: receiver_type,
+        method_name: method_name,
         method_type: MethodType.new(
           method_type,
-          type_params_decl:,
-          type_args:,
+          type_params_decl: type_params_decl,
+          type_args: type_args,
           self_type: rtype,
           instance_type: ::RBS::Types::ClassInstance.new(name: rtype.name, args: type_args, location: nil),
           class_type: ::RBS::Types::ClassSingleton.new(name: rtype.name, location: nil),
         ),
         size_step: @option.size_from.step(to: @option.size_to, by: @option.size_by),
         timeout: @option.timeout,
-        allow_private: true,
+        allow_private: @option.allow_private,
       )
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       stats = prop.run do |called|
@@ -290,7 +309,7 @@ module RaaP
         in Result::Failure => f
           puts 'F'
           if (e = f.exception)
-            RaaP.logger.debug { "Failure: [#{e.class}] #{e.message}" }
+            RaaP.logger.info { "Failure: [#{e.class}] #{e.message}" }
             RaaP.logger.debug { e.backtrace.join("\n") }
           end
           RaaP.logger.debug { PP.pp(f.symbolic_call, ''.dup) }

data/lib/raap/function_type.rb

@@ -7,12 +7,12 @@ module RaaP
     end
 
     def pick_arguments(size: 10)
-      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
+      SymbolicCaller.new(arguments_to_symbolic_call(size: size)).eval
     end
 
     def arguments_to_symbolic_call(size: 10)
-      a = to_symbolic_call_recursive(build_args_type, size:)
-      k = to_symbolic_call_recursive(build_kwargs_type, size:)
+      a = to_symbolic_call_recursive(build_args_type, size: size)
+      k = to_symbolic_call_recursive(build_kwargs_type, size: size)
 
       [a, k]
     end
@@ -24,11 +24,11 @@ module RaaP
       when type.nil?
         nil
       when type.respond_to?(:each_pair)
-        type.each_pair.to_h { |k, v| [k, to_symbolic_call_recursive(v, size:)] }
+        type.each_pair.to_h { |k, v| [k, to_symbolic_call_recursive(v, size: size)] }
       when type.respond_to?(:each)
-        type.each.map { |v| to_symbolic_call_recursive(v, size:) }
+        type.each.map { |v| to_symbolic_call_recursive(v, size: size) }
       else
-        type.to_symbolic_call(size:)
+        type.to_symbolic_call(size: size)
       end
     end
 

data/lib/raap/method_property.rb

@@ -2,7 +2,7 @@
 
 module RaaP
   class MethodProperty
-    class Stats < Struct.new(:success, :skip, :exception, :break)
+    class Stats < Struct.new(:success, :skip, :exception, :break, keyword_init: true)
       def initialize(success: 0, skip: 0, exception: 0, break: false)
         super
       end
@@ -23,7 +23,7 @@ module RaaP
         Timeout.timeout(@timeout) do
           catch(:break) do
             @size_step.each do |size|
-              call(size:, stats:).tap do |ret|
+              call(size: size, stats: stats).tap do |ret|
                 case ret
                 when Result::Success
                   stats.success += 1
@@ -50,13 +50,13 @@ module RaaP
     private
 
     def call(size:, stats:)
-      if @method_type.rbs.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
+      if @method_type.rbs.type.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:)
+      receiver_value = @receiver_type.to_symbolic_call(size: size)
+      args, kwargs, block = @method_type.arguments_to_symbolic_call(size: 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)
@@ -77,25 +77,25 @@ module RaaP
           end
         else
           return_value = symbolic_caller.eval
-          check = check_return(receiver_value:, return_value:)
+          check = check_return(receiver_value: receiver_value, return_value: return_value)
         end
         case check
         in [:success]
-          Result::Success.new(symbolic_call:, return_value:)
+          Result::Success.new(symbolic_call: symbolic_call, return_value: return_value)
         in [:failure]
-          Result::Failure.new(symbolic_call:, return_value:)
+          Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value)
         in [:exception, exception]
-          Result::Exception.new(symbolic_call:, exception:)
+          Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
         end
       rescue TypeError => exception
-        Result::Failure.new(symbolic_call:, return_value:, exception:)
+        Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value, exception: exception)
       end
 
     # not ensure symbolic_call
     rescue NoMethodError, NotImplementedError => exception
-      Result::Skip.new(symbolic_call:, exception:)
+      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
     rescue NameError => e
-      RaaP.logger.error("[#{e.class}] #{e.detailed_message}")
+      RaaP.logger.warn("[#{e.class}] #{e.detailed_message}")
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
       RaaP.logger.warn("Implementation is not found #{msg} maybe.")
       RaaP.logger.debug(e.backtrace&.join("\n"))
@@ -103,9 +103,9 @@ module RaaP
       throw :break
     rescue SystemStackError => exception
       RaaP.logger.info "Found recursive type definition."
-      Result::Skip.new(symbolic_call:, exception:)
+      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
     rescue => exception
-      Result::Exception.new(symbolic_call:, exception:)
+      Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
     end
 
     def check_return(receiver_value:, return_value:)
@@ -126,8 +126,8 @@ module RaaP
         instance_class = BindCall.class(receiver_value)
       end
       type_check = ::RBS::Test::TypeCheck.new(
-        self_class:,
-        instance_class:,
+        self_class: self_class,
+        instance_class: instance_class,
         class_class: Module,
         builder: RBS.builder,
         sample_size: 100,

data/lib/raap/method_type.rb

@@ -20,17 +20,17 @@ module RaaP
       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:)
+      @rbs = ts.method_type_sub(rbs, self_type: self_type, instance_type: instance_type, class_type: class_type)
       @fun_type = FunctionType.new(@rbs.type)
     end
 
     def pick_arguments(size: 10)
-      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
+      SymbolicCaller.new(arguments_to_symbolic_call(size: 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 = @fun_type.arguments_to_symbolic_call(size: size)
+      block = pick_block(size: size)
 
       [args, kwargs, block]
     end
@@ -40,7 +40,7 @@ module RaaP
       return nil if block.nil?
       return nil if (block.required == false) && [true, false].sample
 
-      fixed_return_value = Type.new(block.type.return_type).pick(size:)
+      fixed_return_value = Type.new(block.type.return_type).pick(size: size)
       Proc.new { fixed_return_value }
     end
 

data/lib/raap/minitest.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'minitest'
 
 module RaaP
@@ -11,7 +13,7 @@ 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:)
+          args, kwargs, _block = method_type.pick_arguments(size: size)
           return_value = yield(*args, **kwargs)
           i = BindCall.inspect(return_value)
           c = BindCall.class(return_value)
@@ -28,7 +30,7 @@ module RaaP
           end
         end
         size_step.each do |size|
-          values = types.map { |t| t.pick(size:) }
+          values = types.map { |t| t.pick(size: size) }
           assert yield(*values)
         end
       end

data/lib/raap/symbolic_caller.rb

@@ -121,8 +121,8 @@ module RaaP
       symbolic_call
     end
 
-    def walk(&)
-      _walk(@symbolic_call, true, &)
+    def walk(&block)
+      _walk(@symbolic_call, true, &block)
     end
 
     def _walk(symbolic_call, is_last, &block)

data/lib/raap/type.rb

@@ -39,10 +39,34 @@ module RaaP
       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: 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: size }, nil]
+      end
+    end
+
     # Special class case
     register("::Array") do
       instance = __skip__ = type
-      t = instance.args[0] ? Type.new(instance.args[0], range:) : Type.random
+      t = instance.args[0] ? Type.new(instance.args[0], range: range) : Type.random
       array(t)
     end
     register("::Binding") { sized { binding } }
@@ -63,7 +87,7 @@ module RaaP
     register("::NilClass") { sized { nil } }
     register("::Proc") { sized { Proc.new {} } }
     register("::Rational") { rational }
-    register("::Regexp") { sized { |size| Regexp.new(string.pick(size:)) } }
+    register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
     register("::String") { string }
     register("::Struct") { sized { Struct.new(:foo, :bar).new } }
     register("::Symbol") { symbol }
@@ -94,11 +118,11 @@ module RaaP
     end
 
     def pick(size: 10)
-      to_symbolic_caller(size:).eval
+      to_symbolic_caller(size: size).eval
     end
 
     def to_symbolic_caller(size: 10)
-      SymbolicCaller.new(to_symbolic_call(size:))
+      SymbolicCaller.new(to_symbolic_call(size: size))
     end
 
     def to_symbolic_call(size: 10)
@@ -107,20 +131,20 @@ module RaaP
 
       case type
       when ::RBS::Types::Tuple
-        type.types.map { |t| Type.new(t).to_symbolic_call(size:) }
+        type.types.map { |t| Type.new(t).to_symbolic_call(size: size) }
       when ::RBS::Types::Union
-        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size:) }
+        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size: size) }
       when ::RBS::Types::Intersection
         if type.free_variables.empty?
-          [:call, Value::Intersection, :new, [type.to_s], { size: }, nil]
+          [:call, Value::Intersection, :new, [type.to_s], { size: size }, nil]
         else
-          [:call, Value::Intersection, :new, [type], { size: }, nil]
+          [:call, Value::Intersection, :new, [type], { size: size }, nil]
         end
       when ::RBS::Types::Interface
         if type.free_variables.empty?
-          [:call, Value::Interface, :new, [type.to_s], { size: }, nil]
+          [:call, Value::Interface, :new, [type.to_s], { size: size }, nil]
         else
-          [:call, Value::Interface, :new, [type], { size: }, nil]
+          [:call, Value::Interface, :new, [type], { size: size }, nil]
         end
       when ::RBS::Types::Variable
         [:call, Value::Variable, :new, [type.to_s], {}, nil]
@@ -138,31 +162,33 @@ module RaaP
       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)).to_symbolic_call(size:)
+        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size: 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:)
-        in nil then to_symbolic_call_from_initialize(type, size:)
+        in Proc then instance_exec(&gen).pick(size: size)
+        in nil then to_symbolic_call_from_initialize(type, size: size)
         end
       when ::RBS::Types::Record
         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).to_symbolic_call(size:) }
+        Proc.new { Type.new(type.type.return_type).to_symbolic_call(size: size) }
       when ::RBS::Types::Literal
         type.literal
       when ::RBS::Types::Bases::Bool
-        bool.pick(size:)
+        bool.pick(size: size)
       when ::RBS::Types::Bases::Any
-        Type.random.to_symbolic_call(size:)
+        Type.random.to_symbolic_call(size: size)
       when ::RBS::Types::Bases::Nil
         nil
       else
@@ -175,28 +201,7 @@ module RaaP
     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 = ts.method_type_sub(rbs_method_type)
-        method_type = MethodType.new(maped_rbs_method_type)
-
-        begin
-          try(times: 5, size:) do |size|
-            args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
-            [:call, const, :new, args, kwargs, block]
-          end
-        rescue
-          $stderr.puts "Fail with `#{rbs_method_type}`"
-          raise
-        end
-      else
-        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
-      end
+      Type.call_new_from(const, type, size: size)
     end
 
     def parse(type)
@@ -210,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:).round }
+      sized { |size| float.pick(size: size).round }
     end
 
     def none_zero_integer
@@ -260,16 +240,16 @@ module RaaP
 
     def rational
       sized do |size|
-        a = integer.pick(size:)
-        b = none_zero_integer.pick(size:)
+        a = integer.pick(size: size)
+        b = none_zero_integer.pick(size: size)
         [:call, Kernel, :Rational, [a, b], {}, nil]
       end
     end
 
     def complex
       sized do |size|
-        a = integer.pick(size:)
-        b = none_zero_integer.pick(size:)
+        a = integer.pick(size: size)
+        b = none_zero_integer.pick(size: size)
         [:call, Kernel, :Complex, [a, b], {}, nil]
       end
     end
@@ -294,13 +274,13 @@ module RaaP
 
     def symbol
       sized do |size|
-        string.pick(size:).to_sym
+        string.pick(size: size).to_sym
       end
     end
 
     def array(type)
       sized do |size|
-        Array.new(integer.pick(size:).abs) do
+        Array.new(integer.pick(size: size).abs) do
           type.to_symbolic_call(size: size / 2)
         end
       end
@@ -311,7 +291,7 @@ module RaaP
     def dict(key_type, value_type)
       sized do |size|
         csize = size / 2
-        Array.new(integer.pick(size:).abs).to_h do
+        Array.new(integer.pick(size: size).abs).to_h do
           [
             key_type.to_symbolic_call(size: csize),
             value_type.to_symbolic_call(size: csize)

data/lib/raap/type_substitution.rb

@@ -21,11 +21,14 @@ module RaaP
     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: [],
-        type: method_type.type.sub(sub).then { |ty| sub(ty, self_type:, instance_type:, class_type:) },
-        block: method_type.block&.sub(sub)&.then { |bl| sub(bl, self_type:, instance_type:, class_type:) },
+        type: method_type.type.sub(sub).then { |ty| sub(ty, self_type: self_type, instance_type: instance_type, class_type: class_type) },
+        block: method_type.block&.sub(sub)&.then { |bl| sub(bl, self_type: self_type, instance_type: instance_type, class_type: class_type) },
         location: method_type.location
       )
     end
@@ -46,7 +49,7 @@ module RaaP
         when ::RBS::Types::Bases::Class
           class_type || ty
         else
-          sub(ty, self_type:, instance_type:, class_type:)
+          sub(ty, self_type: self_type, instance_type: instance_type, class_type: class_type)
         end
       end
     end

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,43 +3,69 @@
 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
-        unless @type.instance_of?(::RBS::Types::Interface)
-          ::Kernel.raise ::TypeError, "not an interface type: #{@type}"
-        end
-        @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)
-
-          subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
-
-          BindCall.define_singleton_method(self, name) do |*_, &b|
-            # @type var b: Proc?
-            @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(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:)
-              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)
+          # 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)
+
+          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: self_type, instance_type: instance_type, class_type: class_type)
+
+            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: 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: 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: size)
+          end
+          instance = temp_class.allocate
+          instance.__send__(:initialize, type, size: 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)
@@ -51,7 +77,7 @@ module RaaP
       end
 
       def inspect
-        "#<interface @type=#{@type} @methods=#{@definition.methods.keys} @size=#{@size}>"
+        "#<interface @type=`#{@type}` @methods=#{@definition.methods.keys} @size=#{@size}>"
       end
     end
   end

data/lib/raap/value/intersection.rb

@@ -2,45 +2,38 @@
 
 module RaaP
   module Value
-    class Intersection < BasicObject
-      def initialize(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}"
+    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
-        @children = @type.types.map { |t| Type.new(t).pick(size:) }
-        @size = size
-      end
 
-      def inspect
-        "#<intersection @type.to_s=#{@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)
-        if respond_to?(name)
-          @children.each do |child|
-            if BindCall.respond_to?(child, name)
-              return child.__send__(name, *args, **kwargs, &block)
-            end
+          interfaces = type.types.select do |t|
+            t.instance_of?(::RBS::Types::Interface)
           end
-          ::Kernel.raise
-        else
-          super
-        end
-      end
 
-      def respond_to?(name, include_all = false)
-        @children.any? do |child|
-          if BindCall.instance_of?(child, ::BasicObject)
-            BindCall.respond_to?(child, name, include_all)
-          else
-            child.respond_to?(name, include_all)
+          interfaces.each do |interface|
+            Interface.define_method_from_interface(self, interface, size: size)
           end
         end
+        type = ::RBS::Types::ClassInstance.new(name: TypeName(base.name), args: [], location: nil)
+        SymbolicCaller.new(Type.call_new_from(c, type, size: size)).eval
       end
     end
   end

data/lib/raap/value/module.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RaaP
   module Value
     # FIXME: consider self_types
@@ -30,12 +32,14 @@ module RaaP
                            "#{a_instance.name}[#{args.map(&:to_s).join(', ')}]"
                          end
                        end.then do |ts|
-                         ts << 'Object' if !ts.include?('::BasicObject')
-                         Type.new(ts.join(' & ')).pick(size:)
+                         if !ts.include?('::BasicObject') || ts.any? { |t| t.split('::').last&.start_with?('_') }
+                           ts.unshift('Object')
+                         end
+                         Type.new(ts.uniq.join(' & ')).pick(size: size)
                        end
                      end
         const = ::Object.const_get(@type.name.absolute!.to_s)
-        BindCall.extend(@self_type, const)
+        BindCall.extend(self, const)
       end
 
       def method_missing(name, *args, **kwargs, &block)

data/lib/raap/value/top.rb

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

data/lib/raap/value/variable.rb

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

data/lib/raap/value/void.rb

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

data/lib/raap/version.rb

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

data/lib/raap.rb

@@ -9,6 +9,7 @@ require 'logger'
 
 require_relative 'raap/version'
 require_relative 'raap/value'
+require_relative 'shims'
 
 module RaaP
   class << self

data/lib/shims.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Ruby 3.2
+unless Exception.method_defined?(:detailed_message)
+  class Exception
+    alias detailed_message message
+  end
+end
+
+# Ruby 3.2
+unless defined?(Data)
+  class Data
+    class << self
+      def define(*syms)
+        _ = Class.new do |c|
+          define_method(:initialize) do |*args, **kwargs|
+            if !args.empty?
+              syms.zip(args).each do |sym, arg|
+                instance_variable_set("@#{sym}", arg)
+              end
+            end
+            if !kwargs.empty?
+              kwargs.each do |k, v|
+                instance_variable_set("@#{k}", v)
+              end
+            end
+          end
+
+          syms.each do |sym|
+            c.define_method(sym) do
+              instance_variable_get("@#{sym}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rbs_collection.lock.yaml

@@ -10,7 +10,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: base64
@@ -26,7 +26,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: connection_pool
@@ -34,7 +34,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: date
@@ -54,7 +54,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: io-console
@@ -94,7 +94,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: bc4cbee282cfb013be8c44a3fe7a374491492400
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs

data/sig/raap.rbs

@@ -6,7 +6,7 @@ module RaaP
   def self.logger=: (::Logger) -> void
 
   module BindCall
-    def self.define_singleton_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
+    def self.define_method: (untyped, Symbol) { (*untyped, **untyped) -> untyped } -> void
     def self.respond_to?: (untyped, untyped, ?boolish) -> bool
     def self.instance_of?: (untyped, Module) -> bool
     def self.is_a?: (untyped, Module) -> bool
@@ -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, ?allow_private: bool, ?skips: ::Array[::String]) -> 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, ?allow_private: bool, ?skips: ::Array[::String]) -> 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, :allow_private, :skips]
+      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, :allow_private, :skips]
+      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private]
 
       attr_accessor dirs: ::Array[String]
 
@@ -44,8 +44,6 @@ module RaaP
       attr_accessor size_by: ::Integer
 
       attr_accessor allow_private: bool
-
-      attr_accessor skips: ::Array[String]
     end
 
     type property_result = [Integer, Symbol, ::RBS::MethodType, StringIO?]
@@ -53,7 +51,9 @@ module RaaP
     DEFAULT_SKIP: ::Set[String]
 
     @argv: Array[String]
+    @option: Option
     @results:  Array[{ method: ::RBS::Definition::Method, properties: Array[property_result] }]
+    @skip: ::Set[::String]
 
     def self.option: () -> Option
     def self.option=: (Option) -> void
@@ -220,7 +220,7 @@ module RaaP
 
     def initialize: (::Array[::RBS::AST::TypeParam], ::Array[::RBS::Types::t]) -> void
     def build: () -> ::RBS::Substitution
-    def method_type_sub: (::RBS::MethodType, ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType
+    def method_type_sub: (::RBS::MethodType, ?self_type: ::RBS::Types::t?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType
 
     private
 
@@ -228,7 +228,7 @@ module RaaP
       def map_type: { (untyped) -> untyped } -> untyped
     end
 
-    def sub: (_MapType search, self_type: ::RBS::Types::ClassInstance?, instance_type: ::RBS::Types::ClassInstance?, class_type: ::RBS::Types::ClassSingleton?) -> untyped
+    def sub: (_MapType search, self_type: ::RBS::Types::t?, instance_type: ::RBS::Types::t?, class_type: ::RBS::Types::t?) -> untyped
   end
 
   class Type
@@ -245,6 +245,7 @@ module RaaP
     def self.register: (String) { () [self: instance] -> Sized[untyped] } -> void
     def self.random: () -> Type
     def self.random_without_basic_object: () -> Type
+    def self.call_new_from: (Module, ::RBS::Types::ClassInstance, size: Integer) -> symbolic_call
 
     attr_reader type: ::RBS::Types::t
     attr_reader range: Range[untyped]
@@ -292,9 +293,8 @@ module RaaP
       @type: ::RBS::Types::Interface
       @size: Integer
       @definition: ::RBS::Definition
-      @fixed_return_value: untyped
-      @fixed_block_arguments: Array[untyped]
 
+      def self.define_method_from_interface: (Class base_class, String | ::RBS::Types::Interface type, ?size: Integer) -> void
       def initialize: (String | ::RBS::Types::Interface | String, ?size: Integer) -> void
       def respond_to?: (Symbol, ?boolish) -> bool
       def inspect: () -> String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-14 00:00:00.000000000 Z
+date: 2024-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -76,6 +76,7 @@ files:
 - lib/raap/value/variable.rb
 - lib/raap/value/void.rb
 - lib/raap/version.rb
+- lib/shims.rb
 - public/jacket.webp
 - rbs_collection.lock.yaml
 - rbs_collection.yaml
@@ -94,14 +95,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.2.33
 signing_key:
 specification_version: 4
 summary: RBS as a Property