raap 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13f734d53db009621045979dfc7d705b14c2f378625ff36067784995e8889134
-  data.tar.gz: 472adf32ff8ea739d83a5b41c6a62e80149b29e34d44536df844010eb2e8cb90
+  metadata.gz: a8b20f587b1dff6f9c33beb9e3dd237f130bc260be25f4932cde3a24cc9e795a
+  data.tar.gz: 9080f6e301291b4d0c88a89d640635c900d610ef4886664221f3e056e1694c45
 SHA512:
-  metadata.gz: cc3782c7a65e098eef727163ccc069ca27b339eeaadc7be44abd2eac94c78fa74443c413364e579998dd49aa11c5be38bd27f6504f92759580ec893dd54a3e97
-  data.tar.gz: 68e133fa67a03d4c84ab264c1e0fd1c40204da8995a552e99912eb61c1cddb14d9c81bac26c4aa04615d9833dfa74ad64bd212071dd3195dacad6ae85bd23b54
+  metadata.gz: 35ba388b95030f3bdd79a7050b26d0ef5fe607f2e98596d61c1a8f49630f3bfb301309cac19c0c0bf95c047b042ffa1a0ffd24985259beff7d0bc49fecb19529
+  data.tar.gz: f23bc8a43bd6b7f1295c28b05e0242cf966a589a79f806007d90f468562128ae47e25b8440aaa2be8f3dea2149d7986cedd23b38008eef6f71bccb1f1c0842ab

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.8.0] - 2024-06-09
+
+* Function of interface should not log coverage by @ksss in https://github.com/ksss/raap/pull/11
+* Type-checking block arguments by @ksss in https://github.com/ksss/raap/pull/12
+* Read options directly by @ksss in https://github.com/ksss/raap/pull/13
+* Return value is not checked by @ksss in https://github.com/ksss/raap/pull/14
+
 ## [0.1.0] - 2024-03-20
 
 - Initial release

data/README.md

@@ -57,6 +57,10 @@ Then, you can start loop again.
 
 Finally, you get the perfect RBS!
 
+## Slide
+
+https://speakerdeck.com/ksss/raap
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/lib/raap/cli.rb

@@ -38,9 +38,6 @@ module RaaP
     def initialize(argv)
       # defaults
       @option = Option.new(
-        dirs: [],
-        requires: [],
-        libraries: [],
         timeout: 3,
         size_from: 0,
         size_to: 99,
@@ -55,14 +52,16 @@ module RaaP
 
     def load
       OptionParser.new do |o|
+        o.version = RaaP::VERSION
+
         o.on('-I', '--include PATH') do |path|
-          @option.dirs << path
+          RaaP::RBS.loader.add(path: Pathname(path))
         end
         o.on('--library lib', 'load rbs library') do |lib|
-          @option.libraries << lib
+          RaaP::RBS.loader.add(library: lib, version: nil)
         end
         o.on('--require lib', 'require ruby library') do |lib|
-          @option.requires << lib
+          require lib
         end
         o.on('--log-level level', "default: info") do |arg|
           RaaP.logger.level = arg
@@ -90,16 +89,6 @@ module RaaP
         end
       end.parse!(@argv)
 
-      @option.dirs.each do |dir|
-        RaaP::RBS.loader.add(path: Pathname(dir))
-      end
-      @option.libraries.each do |lib|
-        RaaP::RBS.loader.add(library: lib, version: nil)
-      end
-      @option.requires.each do |lib|
-        require lib
-      end
-
       self
     end
 
@@ -236,7 +225,7 @@ module RaaP
       type_args = type.args
 
       definition = RBS.builder.build_singleton(type_name)
-      type_params_decl = definition.type_params_decl
+      type_params_decl = definition.type_params_decl.freeze
       definition.methods.each do |method_name, method|
         if @skip.include?("#{type_name.absolute!}.#{method_name}")
           RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")
@@ -256,7 +245,7 @@ module RaaP
       end
 
       definition = RBS.builder.build_instance(type_name)
-      type_params_decl = definition.type_params_decl
+      type_params_decl = definition.type_params_decl.freeze
       definition.methods.each do |method_name, method|
         if @skip.include?("#{type_name.absolute!}##{method_name}")
           RaaP.logger.info("Skip #{"#{type_name.absolute!}.#{method_name}"}")

data/lib/raap/coverage.rb

@@ -25,7 +25,7 @@ module RaaP
               RaaP.logger.warn("No location information for `#{phantom_member}`")
               return
             end
-            write_type(io, "return", phantom_member.type, :abs)
+            write_type(io, "return", phantom_member.type)
             io.write(slice(@cur, @cur...phantom_member.location.end_pos))
           else
             RaaP.logger.error("#{phantom_member.class} is not supported")
@@ -37,22 +37,22 @@ module RaaP
           phantom_method_type.type.yield_self do |fun|
             case fun
             when ::RBS::Types::Function
-              fun.required_positionals.each_with_index { |param, i| write_param(io, "req_#{i}", param, :abs) }
-              fun.optional_positionals.each_with_index { |param, i| write_param(io, "opt_#{i}", param, :opt) }
-              fun.rest_positionals&.yield_self         { |param| write_param(io, "rest", param, :opt) }
-              fun.trailing_positionals.each_with_index { |param, i| write_param(io, "trail_#{i}", param, :abs) }
-              fun.required_keywords.each               { |key, param| write_param(io, "keyreq_#{key}", param, :abs) }
-              fun.optional_keywords.each               { |key, param| write_param(io, "key_#{key}", param, :opt) }
-              fun.rest_keywords&.yield_self            { |param| write_param(io, "keyrest", param, :opt) }
+              fun.required_positionals.each_with_index { |param, i| write_param(io, "req_#{i}", param) }
+              fun.optional_positionals.each_with_index { |param, i| write_param(io, "opt_#{i}", param) }
+              fun.rest_positionals&.yield_self         { |param| write_param(io, "rest", param) }
+              fun.trailing_positionals.each_with_index { |param, i| write_param(io, "trail_#{i}", param) }
+              fun.required_keywords.each               { |key, param| write_param(io, "keyreq_#{key}", param) }
+              fun.optional_keywords.each               { |key, param| write_param(io, "key_#{key}", param) }
+              fun.rest_keywords&.yield_self            { |param| write_param(io, "keyrest", param) }
               # when ::RBS::Types::UntypedFunction
             end
           end
 
           phantom_method_type.block&.yield_self do |b|
-            b.type.each_param.with_index { |param, i| write_param(io, "block_param_#{i}", param, :opt) }
-            write_type(io, "block_return", b.type.return_type, :abs)
+            b.type.each_param.with_index { |param, i| write_param(io, "block_param_#{i}", param) }
+            write_type(io, "block_return", b.type.return_type)
           end
-          write_type(io, "return", phantom_method_type.type.return_type, :abs)
+          write_type(io, "return", phantom_method_type.type.return_type)
           raise unless phantom_method_type.location
 
           io.write(slice(@cur, @cur...phantom_method_type.location.end_pos))
@@ -70,11 +70,11 @@ module RaaP
         ml.source[start, range.end - range.begin] or raise
       end
 
-      def write_param(io, position, param, accuracy)
-        write_type(io, position, param.type, accuracy)
+      def write_param(io, position, param)
+        write_type(io, position, param.type)
       end
 
-      def write_type(io, position, type, accuracy)
+      def write_type(io, position, type)
         unless type.location
           RaaP.logger.warn("No location information for `#{type}`")
           return
@@ -88,12 +88,12 @@ module RaaP
             t.location or raise
             io.write(slice(@cur, @cur...t.location.start_pos)) # ( or [
             @cur = t.location.start_pos
-            write_type(io, "#{position}_#{name}_#{i}", t, accuracy)
+            write_type(io, "#{position}_#{name}_#{i}", t)
           end
         when ::RBS::Types::Optional
           raise unless type.location
 
-          write_type(io, "#{position}_optional_left", type.type, accuracy)
+          write_type(io, "#{position}_optional_left", type.type)
           io.write(slice(@cur, @cur...(type.location.end_pos - 1)))
           @cur = type.location.end_pos - 1
           if @cov.include?("#{position}_optional_right".to_sym)
@@ -103,17 +103,6 @@ module RaaP
           end
           raise unless type.location
 
-          @cur = type.location.end_pos
-        when ::RBS::Types::Variable
-          case accuracy
-          when :abs
-            io.write(green(type.name.to_s))
-          when :opt
-            # Variables are substed so raap don't know if they've been used.
-            io.write(yellow(type.name.to_s))
-          end
-          raise unless type.location
-
           @cur = type.location.end_pos
         else
           raise unless type.location
@@ -129,7 +118,6 @@ module RaaP
 
       def green(str) = "\e[32m#{str}\e[0m"
       def red(str) = "\e[1;4;41m#{str}\e[0m"
-      def yellow(str) = "\e[93m#{str}\e[0m"
     end
 
     class << self
@@ -142,8 +130,6 @@ module RaaP
         !!@cov
       end
 
-      # position: req_0
-      # type: union_1
       def log(position)
         return unless running?
 
@@ -151,7 +137,7 @@ module RaaP
       end
 
       def cov
-        @cov or raise
+        @cov or raise("Coverage is not started")
       end
 
       def show(io)
@@ -162,25 +148,31 @@ module RaaP
       end
 
       def new_type_with_log(position, type)
+        log_with_type(position, type) do |t|
+          Type.new(t)
+        end
+      end
+
+      def log_with_type(position, type, &block)
         case type
         when ::RBS::Types::Tuple
           # FIXME: Support Union in Tuple
           type.types.each_with_index do |_t, i|
             log("#{position}_tuple_#{i}")
           end
-          Type.new(type)
+          block&.call(type)
         when ::RBS::Types::Union
           i = Random.rand(type.types.length)
-          new_type_with_log("#{position}_union_#{i}", type.types[i])
+          log_with_type("#{position}_union_#{i}", type.types[i], &block)
         when ::RBS::Types::Optional
           if Random.rand(2).zero?
-            new_type_with_log("#{position}_optional_left", type.type)
+            log_with_type("#{position}_optional_left", type.type, &block)
           else
-            new_type_with_log("#{position}_optional_right", ::RBS::Types::Bases::Nil.new(location: nil))
+            log_with_type("#{position}_optional_right", ::RBS::Types::Bases::Nil.new(location: nil), &block)
           end
         else
           log(position)
-          Type.new(type)
+          block&.call(type)
         end
       end
     end

data/lib/raap/function_type.rb

@@ -2,8 +2,9 @@
 
 module RaaP
   class FunctionType
-    def initialize(fun)
+    def initialize(fun, coverage: true)
       @fun = fun
+      @coverage = coverage
     end
 
     def pick_arguments(size: 10)
@@ -81,7 +82,11 @@ module RaaP
     end
 
     def build_type_with_coverage(position, param)
-      Coverage.new_type_with_log(position, param.type)
+      if @coverage
+        Coverage.new_type_with_log(position, param.type)
+      else
+        Type.new(param.type)
+      end
     end
   end
 end

data/lib/raap/method_property.rb

@@ -50,7 +50,7 @@ module RaaP
     private
 
     def call(size:, stats:)
-      if @method_type.rbs.type.each_type.find { |t| t.instance_of?(::RBS::Types::Bases::Any) }
+      if @method_type.rbs.type.each_param.find { |param| param.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

data/lib/raap/method_type.rb

@@ -2,7 +2,7 @@
 
 module RaaP
   class MethodType
-    attr_reader :rbs, :original_rbs
+    attr_reader :rbs
 
     def initialize(method, type_params_decl: [], type_args: [], self_type: nil, instance_type: nil, class_type: nil)
       rbs =
@@ -19,11 +19,17 @@ module RaaP
 
       params = (type_params_decl + rbs.type_params).uniq
       ts = TypeSubstitution.new(params, type_args)
-
-      @original_rbs = rbs
       @rbs = ts.method_type_sub(rbs, self_type: self_type, instance_type: instance_type, class_type: class_type)
       function_or_untypedfunction = __skip__ = @rbs.type
       @fun_type = FunctionType.new(function_or_untypedfunction)
+      @type_check = ::RBS::Test::TypeCheck.new(
+        self_class: (_ = self_type),
+        instance_class: (_ = instance_type),
+        class_class: (_ = class_type),
+        builder: RBS.builder,
+        sample_size: 100,
+        unchecked_classes: []
+      )
     end
 
     def pick_arguments(size: 10)
@@ -42,28 +48,63 @@ 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: size)
-      Proc.new do
-        block.type.each_param.with_index do |_param, i|
-          Coverage.log("block_param_#{i}")
+      args_name = []
+      args_source = []
+      resource = [*'a'..'z']
+      case fun = block.type
+      when ::RBS::Types::Function
+        # FIXME: Support keyword types
+        fun.required_positionals.each do
+          resource.shift.tap do |name|
+            args_name << name
+            args_source << name
+          end
+        end
+        fun.optional_positionals.each do |param|
+          resource.shift.tap do |name|
+            # FIXME: Support without literal type
+            default = Type.new(param.type).pick(size: size)
+            args_name << name
+            args_source << "#{name} = #{default}"
+          end
+        end
+        fun.rest_positionals&.yield_self do |_|
+          resource.shift.tap do |name|
+            args_name << "*#{name}"
+            args_source << "*#{name}"
+          end
+        end
+        fun.trailing_positionals.each do
+          resource.shift.tap do |name|
+            args_name << name
+            args_source << name
+          end
         end
-
-        Coverage.new_type_with_log("block_return", block.type.return_type)
-        fixed_return_value
       end
+      # Hack: Use local variable in eval
+      fixed_return_value = Type.new(block.type.return_type).pick(size: size)
+      _ = fixed_return_value
+      type_check = @type_check
+      _ = type_check
+      eval(<<~RUBY) # rubocop:disable Security/Eval
+        -> (#{args_source.join(', ')}) do
+          i = 0
+          type_check.zip_args([#{args_name.join(', ')}], block.type) do |val, param|
+            unless type_check.value(val, param.type)
+              raise TypeError, "block argument type mismatch: expected `(\#{fun.param_to_s})`, got \#{BindCall.inspect([#{args_name.join(', ')}])}"
+            end
+
+            Coverage.log_with_type("block_param_\#{i}", param.type)
+            i += 1
+          end
+          Coverage.log_with_type("block_return", block.type.return_type)
+          fixed_return_value
+        end
+      RUBY
     end
 
     def check_return(return_value)
-      untyped = __skip__ = nil
-      type_check = ::RBS::Test::TypeCheck.new(
-        self_class: untyped,     # cannot support `self`
-        instance_class: untyped, # cannot support `instance`
-        class_class: untyped,    # cannot support `class`
-        builder: RBS.builder,
-        sample_size: 100,
-        unchecked_classes: []
-      )
-      type_check.value(return_value, rbs.type.return_type)
+      @type_check.value(return_value, rbs.type.return_type)
     end
   end
 end

data/lib/raap/symbolic_caller.rb

@@ -148,9 +148,17 @@ module RaaP
     def eval_one(symbolic_call)
       symbolic_call => [:call, receiver_value, method_name, args, kwargs, block]
       if @allow_private
-        receiver_value.__send__(method_name, *args, **kwargs, &block)
+        if kwargs.empty?
+          receiver_value.__send__(method_name, *args, &block)
+        else
+          receiver_value.__send__(method_name, *args, **kwargs, &block)
+        end
       else
-        BindCall.public_send(receiver_value, method_name, *args, **kwargs, &block)
+        if kwargs.empty?
+          BindCall.public_send(receiver_value, method_name, *args, &block)
+        else
+          BindCall.public_send(receiver_value, method_name, *args, **kwargs, &block)
+        end
       end
     end
 

data/lib/raap/type.rb

@@ -47,7 +47,7 @@ module RaaP
       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))
+        type_params = definition.type_params_decl.dup.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)

data/lib/raap/value/interface.rb

@@ -33,7 +33,7 @@ module RaaP
               if b && subed_method_type.block && subed_method_type.block.type.is_a?(::RBS::Types::Function)
                 @fixed_block_arguments ||= {}
                 @fixed_block_arguments[name] ||= size.times.map do
-                  FunctionType.new(subed_method_type.block.type)
+                  FunctionType.new(subed_method_type.block.type, coverage: false)
                               .pick_arguments(size: size)
                 end
 

data/lib/raap/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - ksss
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-08 00:00:00.000000000 Z
+date: 2024-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -46,13 +46,10 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- Steepfile
 - exe/raap
 - lib/raap.rb
 - lib/raap/bind_call.rb
@@ -78,12 +75,6 @@ files:
 - lib/raap/value/void.rb
 - lib/raap/version.rb
 - lib/shims.rb
-- public/example.webp
-- public/jacket.webp
-- rbs_collection.lock.yaml
-- rbs_collection.yaml
-- sig/raap.rbs
-- sig/shims.rbs
 homepage: https://github.com/ksss/raap
 licenses:
 - MIT
@@ -97,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.0
+      version: 3.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.rubocop.yml

@@ -1,33 +0,0 @@
-AllCops:
-  TargetRubyVersion: 3.0
-  NewCops: enable
-  Include:
-  - 'lib/**/*.rb'
-
-Lint:
-  Enabled: true
-Lint/EmptyBlock:
-  Enabled: false
-Lint/SymbolConversion:
-  Enabled: false
-
-Style:
-  Enabled: false
-Style/HashSyntax:
-  EnforcedShorthandSyntax: always
-  Enabled: true
-Style/FrozenStringLiteralComment:
-  Enabled: true
-
-Metrics:
-  Enabled: false
-
-Layout:
-  Enabled: true
-Layout/FirstArrayElementIndentation:
-  EnforcedStyle: consistent
-Layout/LineLength:
-  Max: 150
-
-Naming:
-  Enabled: false

data/Rakefile

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "minitest/test_task"
-require "rubocop/rake_task"
-
-Minitest::TestTask.create do |t|
-  t.test_prelude = 'require "test/test_helper"'
-end
-
-RuboCop::RakeTask.new
-
-namespace :steep do
-  task :check do
-    sh "bundle exec steep check"
-  end
-end
-
-task default: [:test, :rubocop, 'steep:check']

data/Steepfile

@@ -1,4 +0,0 @@
-target :lib do
-  check "lib"
-  signature "sig"
-end

data/rbs_collection.lock.yaml

@@ -1,128 +0,0 @@
----
-path: ".gem_rbs_collection"
-gems:
-- name: abbrev
-  version: '0'
-  source:
-    type: stdlib
-- name: activesupport
-  version: '7.0'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
-- name: base64
-  version: '0'
-  source:
-    type: stdlib
-- name: bigdecimal
-  version: '0'
-  source:
-    type: stdlib
-- name: concurrent-ruby
-  version: '1.1'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
-- name: connection_pool
-  version: '2.4'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
-- name: date
-  version: '0'
-  source:
-    type: stdlib
-- name: erb
-  version: '0'
-  source:
-    type: stdlib
-- name: fileutils
-  version: '0'
-  source:
-    type: stdlib
-- name: i18n
-  version: '1.10'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
-- name: io-console
-  version: '0'
-  source:
-    type: stdlib
-- name: json
-  version: '0'
-  source:
-    type: stdlib
-- name: logger
-  version: '0'
-  source:
-    type: stdlib
-- name: minitest
-  version: '0'
-  source:
-    type: stdlib
-- name: monitor
-  version: '0'
-  source:
-    type: stdlib
-- name: mutex_m
-  version: '0'
-  source:
-    type: stdlib
-- name: optparse
-  version: '0'
-  source:
-    type: stdlib
-- name: pathname
-  version: '0'
-  source:
-    type: stdlib
-- name: rake
-  version: '13.0'
-  source:
-    type: git
-    name: ruby/gem_rbs_collection
-    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    repo_dir: gems
-- name: rbs
-  version: 3.4.4
-  source:
-    type: rubygems
-- name: rdoc
-  version: '0'
-  source:
-    type: stdlib
-- name: securerandom
-  version: '0'
-  source:
-    type: stdlib
-- name: singleton
-  version: '0'
-  source:
-    type: stdlib
-- name: time
-  version: '0'
-  source:
-    type: stdlib
-- name: timeout
-  version: '0'
-  source:
-    type: stdlib
-- name: tsort
-  version: '0'
-  source:
-    type: stdlib
-gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -1,19 +0,0 @@
-# Download sources
-sources:
-  - type: git
-    name: ruby/gem_rbs_collection
-    remote: https://github.com/ruby/gem_rbs_collection.git
-    revision: main
-    repo_dir: gems
-
-# You can specify local directories as sources also.
-# - type: local
-#   path: path/to/your/local/repository
-
-# A directory to install the downloaded RBSs
-path: .gem_rbs_collection
-
-gems:
-  - name: activesupport
-  - name: steep
-    ignore: true

data/sig/raap.rbs

@@ -1,385 +0,0 @@
-module RaaP
-  type symbolic_call = [:call, untyped, Symbol, Array[untyped], Hash[Symbol, untyped], Proc?]
-  VERSION: String
-
-  def self.logger: () -> ::Logger
-  def self.logger=: (::Logger) -> void
-
-  module BindCall
-    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
-    def self.extend: (untyped, Module) -> void
-    def self.name: (Module) -> String?
-    def self.to_s: (untyped) -> String
-    def self.class: (untyped) -> untyped
-    def self.inspect: (untyped) -> String
-  end
-
-  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, ?coverage: 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, ?coverage: bool) -> instance
-
-      def self.keyword_init?: () -> true
-
-      def self.members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
-
-      def members: () -> [ :dirs, :requires, :library, :timeout, :size_from, :size_to, :size_by, :allow_private, :coverage]
-
-      attr_accessor dirs: ::Array[String]
-
-      attr_accessor requires: ::Array[String]
-
-      attr_accessor libraries: ::Array[String]
-
-      attr_accessor timeout: (Integer | Float | nil)
-
-      attr_accessor size_from: ::Integer
-
-      attr_accessor size_to: ::Integer
-
-      attr_accessor size_by: ::Integer
-
-      attr_accessor allow_private: bool
-
-      attr_accessor coverage: bool
-    end
-
-    type property_result = [Integer, Symbol, ::RBS::MethodType, StringIO?]
-
-    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
-
-    def initialize: (Array[String]) -> void
-    def load: () -> self
-    def run: () -> Integer
-
-    private
-
-    def run_by: (kind: (:instance | :singleton), tag: String) -> void
-    def run_by_type_name: (tag: String) -> void
-    def run_by_type_name_with_search: (tag: String) -> void
-    def property: (receiver_type: Type, type_params_decl: Array[::RBS::AST::TypeParam], type_args: Array[::RBS::Types::t], method_name: Symbol, method_type: ::RBS::MethodType) -> property_result
-    def report: () -> Integer
-  end
-
-  module Coverage
-    type locs = [::RBS::Buffer::loc, ::RBS::Buffer::loc]
-    type accuracy = :abs | :opt
-    class Writer
-      @method_type: ::RBS::MethodType
-      @cov: ::Set[Symbol]
-      @cur: Integer
-
-      def initialize: (::RBS::MethodType, Set[Symbol]) -> void
-      def write: (IO) -> void
-
-      private
-
-      def method_type_location: () -> ::RBS::Location[untyped, untyped]
-      def slice: (Integer, Range[Integer]) -> String
-      def write_param: (IO, String, ::RBS::Types::Function::Param, accuracy) -> void
-      def write_type: (IO, String, ::RBS::Types::t, accuracy) -> void
-      def green: (String) -> String
-      def red: (String) -> String
-      def yellow: (String) -> String
-    end
-
-    self.@cov: Set[Symbol]?
-    self.@method_type: ::RBS::MethodType
-
-    def self.start: (::RBS::MethodType) -> void
-    def self.running?: () -> bool
-    def self.log: (String | Symbol) -> void
-    def self.cov: () -> Set[Symbol]
-    def self.show: (IO) -> void
-    def self.new_type_with_log: (String, ::RBS::Types::t) -> Type
-  end
-
-  class FunctionType
-    @fun: ::RBS::Types::Function
-
-    def initialize: (::RBS::Types::Function) -> void
-    def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
-    def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped]]
-
-    private
-
-    def to_symbolic_call_recursive: (untyped, size: Integer) -> untyped
-    def build_args_type: () -> Array[Type]
-    def build_kwargs_type: () -> Hash[Symbol, Type]
-    def build_type_with_coverage: (String, ::RBS::Types::Function::Param) -> Type
-  end
-
-  class MethodProperty
-    class Stats
-      attr_accessor success: Integer
-      attr_accessor skip: Integer
-      attr_accessor exception: Integer
-      attr_accessor break: bool
-    end
-
-    @receiver_type: Type
-    @method_name: Symbol
-    @method_type: MethodType
-    @size_step: _Each[Integer]
-    @timeout: (Integer | Float | nil)
-    @allow_private: bool
-
-    def initialize: (receiver_type: Type, method_name: Symbol, method_type: MethodType, size_step: _Each[Integer], timeout: (Integer | Float | nil), ?allow_private: bool) -> void
-    def run: () { (Result::Success | Result::Failure | Result::Skip | Result::Exception) -> void } -> Stats
-
-    private
-
-    def call: (size: Integer, stats: Stats) -> (Result::Success | Result::Failure | Result::Skip | Result::Exception)
-    def check_return: (receiver_value: untyped, return_value: untyped) -> ([Symbol] | [Symbol, Exception])
-    def return_type: () -> RBS::Types::t
-    def original_return_type: () -> RBS::Types::t
-    def coverage: (String, untyped, RBS::Types::t, ?RBS::Test::TypeCheck?) -> void
-  end
-
-  class MethodType
-    attr_reader rbs: ::RBS::MethodType
-    attr_reader original_rbs: ::RBS::MethodType
-    @fun_type: FunctionType
-
-    def initialize: (::RBS::MethodType | String method, ?type_params_decl: Array[untyped], ?type_args: Array[untyped], ?self_type: ::RBS::Types::ClassInstance?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> void
-    def pick_arguments: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
-    def arguments_to_symbolic_call: (?size: Integer) -> [Array[untyped], Hash[Symbol, untyped], ::Proc?]
-    def pick_block: (?size: Integer) -> ::Proc?
-    def check_return: (untyped) -> bool
-  end
-
-  module Minitest
-  end
-
-  module RBS
-    self.@builder: ::RBS::DefinitionBuilder
-    self.@env: ::RBS::Environment
-    self.@loader: ::RBS::EnvironmentLoader
-
-    def self.builder: () -> ::RBS::DefinitionBuilder
-    def self.env: () -> ::RBS::Environment
-    def self.loader: () -> ::RBS::EnvironmentLoader
-    def self.parse_type: (String) -> ::RBS::Types::t
-    def self.parse_method_type: (String) -> ::RBS::MethodType
-    def self.parse_member: (String) -> ::RBS::AST::Members::Attribute
-    def self._shift_location: (untyped, Integer) -> void
-    def self.find_alias_decl: (::RBS::TypeName, Symbol) -> ::RBS::AST::Members::Alias?
-  end
-
-  module Result
-    interface _ReturnValue
-      def return_value: () -> untyped
-    end
-
-    module ReturnValueWithType : _ReturnValue
-      def return_value_with_type: () -> String
-
-      private
-
-      def return_value_to_type: (untyped) -> String
-    end
-
-    class Success < Data
-      include ReturnValueWithType
-      def self.new: (symbolic_call: symbolic_call, return_value: untyped) -> instance
-      attr_reader symbolic_call: symbolic_call
-      attr_reader return_value: untyped
-      def called_str: () -> String
-    end
-    class Failure < Data
-      include ReturnValueWithType
-      def self.new: (symbolic_call: symbolic_call, return_value: untyped, ?exception: ::Exception?) -> instance
-      attr_reader symbolic_call: symbolic_call
-      attr_reader return_value: untyped
-      attr_reader exception: ::Exception?
-      def called_str: () -> String
-    end
-    class Skip < Data
-      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
-      attr_reader symbolic_call: symbolic_call?
-      attr_reader exception: ::Exception
-    end
-    class Exception < Data
-      def self.new: (symbolic_call: symbolic_call?, exception: ::Exception) -> instance
-      attr_reader symbolic_call: symbolic_call?
-      attr_reader exception: ::Exception
-    end
-  end
-
-  class Sized[T]
-    @block: ::Proc
-    @such_that: ::Proc?
-
-    def initialize: () { (Integer) -> untyped } -> void
-    def pick: (size: Integer) -> T
-    def such_that: () { (untyped) -> boolish } -> self
-    def such_that_loop: [R] () { (Integer) -> R } -> R
-  end
-
-  class SymbolicCaller
-    class Var
-      attr_reader name: String
-      def initialize: (String name) -> void
-      def +: (String) -> String
-      def to_s: () -> String
-    end
-
-    attr_reader symbolic_call: untyped
-    attr_reader allow_private: bool
-
-    def initialize: (untyped, ?allow_private: bool) -> void
-    def eval: () -> untyped
-    def call_str: () -> String
-    def to_lines: () -> Array[String]
-
-    private
-
-    def try_eval: (untyped) -> untyped
-    def walk: () ?{ (symbolic_call) -> untyped} -> untyped
-    def _walk: (untyped, bool is_last) ?{ (symbolic_call) -> untyped} -> untyped
-    def eval_one: (symbolic_call) -> untyped
-    def var_name: (Module) -> String
-    def printable?: (untyped) -> bool
-    def printable: (untyped) -> String
-  end
-
-  class TypeSubstitution
-    @type_params: ::Array[::RBS::AST::TypeParam]
-    @type_args: ::Array[::RBS::Types::t]
-
-    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::t?, ?instance_type: ::RBS::Types::ClassInstance?, ?class_type: ::RBS::Types::ClassSingleton?) -> ::RBS::MethodType
-
-    private
-
-    interface _MapType
-      def map_type: { (untyped) -> untyped } -> untyped
-    end
-
-    def sub: (_MapType search, self_type: ::RBS::Types::t?, instance_type: ::RBS::Types::t?, class_type: ::RBS::Types::t?) -> untyped
-  end
-
-  class Type
-    module Arithmetic
-      def self.float: () -> Float
-      def self.positive_float: () -> Float
-    end
-
-    @such_that: (^(untyped) -> ::boolish)?
-
-    GENERATORS: Hash[String, ^() -> Sized[untyped]]
-    SIMPLE_SOURCE: Array[String]
-
-    def self.register: (String) { () [self: instance] -> 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]
-
-    def initialize: (String | ::RBS::Types::t, ?range: Range[untyped]) -> void
-
-    # Define rule for generating values
-    #     type.such_that { |i| i != 0 }.pick #=> ensure that the value is not 0
-    def such_that: () { (untyped) -> boolish } -> self
-
-    # Basic API for materializing values
-    def pick: (?size: Integer) -> untyped
-    def to_symbolic_caller: (?size: Integer) -> SymbolicCaller
-    def to_symbolic_call: (?size: Integer) -> untyped
-    def sized: [T] () { (Integer size) -> T } -> Sized[T]
-
-    private
-
-    def to_symbolic_call_from_initialize: (::RBS::Types::ClassInstance, size: Integer) -> (symbolic_call | Value::Module)
-    def parse: (String | ::RBS::Types::t) -> ::RBS::Types::t?
-    def try: (times: Integer, size: Integer) { (Integer size) -> untyped } -> untyped
-
-    def numeric: () -> Sized[Numeric]
-    def integer: () -> Sized[Integer]
-    def none_zero_integer: () -> Sized[Integer]
-    def float: () -> Sized[Float]
-    def rational: () -> Sized[symbolic_call]
-    def complex: () -> Sized[symbolic_call]
-    def string: () -> Sized[String]
-    def symbol: () -> Sized[Symbol]
-    def array: (Type) -> Sized[Array[untyped]]
-    def dict: (Type, Type) -> Sized[Hash[untyped, untyped]]
-    def encoding: () -> symbolic_call
-    def bool: () -> bool
-    def temp_method_object: () -> ::Method
-  end
-
-  module Value
-    class Bottom < BasicObject
-      def inspect: () -> String
-      def class: () -> class
-    end
-
-    class Interface
-      @type: ::RBS::Types::Interface
-      @size: Integer
-      @definition: ::RBS::Definition
-
-      def self.define_method_from_interface: (::Module 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
-      def class: () -> class
-    end
-
-    module Intersection
-      @type: ::RBS::Types::Intersection
-      @children: Array[Type]
-      @size: Integer
-
-      def initialize: (::RBS::Types::Intersection | String, ?size: Integer) -> void
-      def respond_to?: (Symbol, ?boolish) -> bool
-      def inspect: () -> String
-      def class: () -> class
-    end
-
-    class Module < BasicObject
-      @type: ::RBS::Types::ClassInstance
-      @size: Integer
-      @self_type: untyped
-
-      def initialize: (::RBS::Types::ClassInstance | String, ?size: Integer) -> void
-      def respond_to?: (Symbol, ?boolish) -> bool
-      def inspect: () -> String
-      def class: () -> class
-    end
-
-    class Top < BasicObject
-      def inspect: () -> String
-      def class: () -> class
-    end
-
-    class Variable
-      attr_reader type: ::RBS::Types::Variable
-
-      def initialize: (::RBS::Types::Variable | String | Symbol) -> void
-      def inspect: () -> String
-      def class: () -> class
-    end
-
-    class Void < BasicObject
-      def inspect: () -> String
-      def class: () -> class
-    end
-  end
-end

data/sig/shims.rbs

@@ -1,4 +0,0 @@
-module Timeout
-  class ExitException < Exception
-  end
-end