raap 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94f0ec4ff924c5089f8e307002dd5f3cd778f04e686acd8b46466139c3c1aebd
-  data.tar.gz: e9a06fb3c71cfc6cd605031fe8cb899a123dc82a94ef00586d39e8329c45beac
+  metadata.gz: 13f734d53db009621045979dfc7d705b14c2f378625ff36067784995e8889134
+  data.tar.gz: 472adf32ff8ea739d83a5b41c6a62e80149b29e34d44536df844010eb2e8cb90
 SHA512:
-  metadata.gz: ed0d647fefa8591c0a03981232c84d64bf7c70bcf9207d2dd6471a9f3369747b5dd3adcc3cd60a8e1d65f0e1543ed7a5f5108eef6523c7d306cfc399d0bc63e4
-  data.tar.gz: 537c5dfbb65bb12064e46c47fb75a60321ee0f16296f1272ef27d68927f4f9f3d5875ea6f3ac2225c76a2d274fbe393bff20f573b8d138b52a6ced8027528e1f
+  metadata.gz: cc3782c7a65e098eef727163ccc069ca27b339eeaadc7be44abd2eac94c78fa74443c413364e579998dd49aa11c5be38bd27f6504f92759580ec893dd54a3e97
+  data.tar.gz: 68e133fa67a03d4c84ab264c1e0fd1c40204da8995a552e99912eb61c1cddb14d9c81bac26c4aa04615d9833dfa74ad64bd212071dd3195dacad6ae85bd23b54

data/.rubocop.yml

@@ -1,5 +1,5 @@
 AllCops:
-  TargetRubyVersion: 3.3
+  TargetRubyVersion: 3.0
   NewCops: enable
   Include:
   - 'lib/**/*.rb'
@@ -8,6 +8,8 @@ Lint:
   Enabled: true
 Lint/EmptyBlock:
   Enabled: false
+Lint/SymbolConversion:
+  Enabled: false
 
 Style:
   Enabled: false

data/README.md

@@ -1,6 +1,6 @@
 # RaaP
 
-<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=400/>
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/jacket.webp" width=500/>
 
 ## RBS as a Property
 
@@ -14,6 +14,10 @@ The return value of the method is checked to see if it matches the type, if not,
 
 If you write an RBS, it becomes a test case.
 
+## Example
+
+<img src="https://raw.githubusercontent.com/ksss/raap/main/public/example.webp" width=700/>
+
 ## Concept
 
 If you has next signature.
@@ -70,7 +74,7 @@ $ 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 method MyClass without #skip
+$ raap 'MyClass' '!MyClass#skip'  # Run methods MyClass without #skip
 ```
 
 ```
@@ -81,6 +85,27 @@ MyClass
 $ 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.
+
+## Coverage
+
+RaaP randomly selects a type and generates a value for optional and union types.
+
+By default, displays the coverage of the type that actually produced the value.
+
+The coverage display can help you determine if a correction is needed.
+
+### Meaning of colored types
+
+- 🔴 Red: A type that has never been used to generate or validate a value.
+- 🟡 Yellow: It is systematically difficult to determine if the type was used or not. (FIXME)
+- 🟢 Green: The type used to generate and validate the value.
+
 ## Size
 
 Random values are determined based on size.
@@ -143,6 +168,42 @@ You can specify size of step like `Integer#step: (to: Integer, by: Integer)`.
 By default, raap only validates public methods.
 However, by setting this option, it is possible to intentionally validate private methods in the RBS.
 
+### `--preload path`
+
+Simply call `Kernel.load`.
+However, this simplifies the preliminary preparation.
+
+#### Preload examples
+
+1) Check signature of aws-sdk-s3
+
+```rb
+$ cat preload.rb
+require 'aws-sdk-s3'
+
+# Register initialize of `Aws::S3::Client` class.
+RaaP::Type.register("Aws::S3::Client") do
+  [:call, Aws::S3::Client, :new, [], { stub_responses: true }, nil]
+end
+
+$ raap --preload ./preload.rb 'Aws::S3::Client#get_object'
+```
+
+2) Output ruby coverage by simplecov
+
+```rb
+$ cat preload.rb
+require 'simplecov'
+
+SimpleCov.command_name 'raap'
+SimpleCov.start do
+  enable_coverage :branch
+  add_filter "/test/"
+end
+
+$ bundle exec raap --preload ./preload.rb -r my_class 'MyClass'
+```
+
 ## 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/lib/raap/cli.rb

@@ -12,6 +12,7 @@ module RaaP
       :size_to,
       :size_by,
       :allow_private,
+      :coverage,
       keyword_init: true
     )
 
@@ -44,6 +45,7 @@ module RaaP
         size_from: 0,
         size_to: 99,
         size_by: 1,
+        coverage: true,
         allow_private: false,
       )
       @argv = argv
@@ -80,6 +82,12 @@ module RaaP
         o.on('--allow-private', "default: #{@option.allow_private}") do
           @option.allow_private = true
         end
+        o.on('--preload path', 'Kernel.load path') do |path|
+          Kernel.load path
+        end
+        o.on('--[no-]coverage', "Show coverage for RBS (default: #{@option.coverage})") do |arg|
+          @option.coverage = arg
+        end
       end.parse!(@argv)
 
       @option.dirs.each do |dir|
@@ -104,7 +112,7 @@ module RaaP
 
       # Search skip tag
       @argv.each do |tag|
-        if tag.start_with?('!') && (tag.include?('#') || tag.include?('.'))
+        if tag.start_with?('!')
           t = tag[1..] or raise
           t = "::#{t}" unless t.start_with?('::')
           t or raise
@@ -118,13 +126,13 @@ module RaaP
 
         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
 
@@ -198,9 +206,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
@@ -238,9 +247,10 @@ module RaaP
 
         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
@@ -257,9 +267,10 @@ module RaaP
 
         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
@@ -283,12 +294,12 @@ module RaaP
       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),
@@ -297,6 +308,7 @@ module RaaP
         timeout: @option.timeout,
         allow_private: @option.allow_private,
       )
+      RaaP::Coverage.start(method_type) if @option.coverage
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       stats = prop.run do |called|
         case called
@@ -334,6 +346,9 @@ module RaaP
       end
       end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       puts
+      RaaP::Coverage.show($stdout) if @option.coverage
+      puts
+
       time_diff = end_time - start_time
       time = ", time: #{(time_diff * 1000).round}ms"
       stats_log = "success: #{stats.success}, skip: #{stats.skip}, exception: #{stats.exception}#{time}"

data/lib/raap/coverage.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RaaP
+  module Coverage
+    class Writer
+      def initialize(method_type, cov)
+        @method_type = method_type
+        @cov = cov
+        @cur = 0
+      end
+
+      def write(io)
+        RaaP.logger.debug { "Coverage: #{@cov}" }
+        ml = @method_type.location
+        unless ml
+          RaaP.logger.warn("No location information for `#{@method_type}`")
+          return
+        end
+        if ml.key?(:keyword)
+          # attr_{reader,writer,accessor}
+          phantom_member = RBS.parse_member(ml.source)
+          case phantom_member
+          when ::RBS::AST::Members::Attribute
+            unless phantom_member.location
+              RaaP.logger.warn("No location information for `#{phantom_member}`")
+              return
+            end
+            write_type(io, "return", phantom_member.type, :abs)
+            io.write(slice(@cur, @cur...phantom_member.location.end_pos))
+          else
+            RaaP.logger.error("#{phantom_member.class} is not supported")
+            return
+          end
+        else
+          # def name: () -> type
+          phantom_method_type = RBS.parse_method_type(ml.source)
+          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) }
+              # 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)
+          end
+          write_type(io, "return", phantom_method_type.type.return_type, :abs)
+          raise unless phantom_method_type.location
+
+          io.write(slice(@cur, @cur...phantom_method_type.location.end_pos))
+        end
+
+        io.puts
+      end
+
+      private
+
+      def slice(start, range)
+        ml = @method_type.location
+        raise unless ml
+
+        ml.source[start, range.end - range.begin] or raise
+      end
+
+      def write_param(io, position, param, accuracy)
+        write_type(io, position, param.type, accuracy)
+      end
+
+      def write_type(io, position, type, accuracy)
+        unless type.location
+          RaaP.logger.warn("No location information for `#{type}`")
+          return
+        end
+        io.write(slice(@cur, @cur...type.location.start_pos))
+        @cur = type.location.start_pos
+        case type
+        when ::RBS::Types::Tuple, ::RBS::Types::Union
+          name = type.class.name.split('::').last.downcase
+          type.types.each_with_index do |t, i|
+            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)
+          end
+        when ::RBS::Types::Optional
+          raise unless type.location
+
+          write_type(io, "#{position}_optional_left", type.type, accuracy)
+          io.write(slice(@cur, @cur...(type.location.end_pos - 1)))
+          @cur = type.location.end_pos - 1
+          if @cov.include?("#{position}_optional_right".to_sym)
+            io.write(green('?'))
+          else
+            io.write(red('?'))
+          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
+
+          if @cov.include?(position.to_sym)
+            io.write(green(type.location.source))
+          else
+            io.write(red(type.location.source))
+          end
+          @cur = type.location.end_pos
+        end
+      end
+
+      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
+      def start(method_type)
+        @cov = Set.new
+        @method_type = method_type
+      end
+
+      def running?
+        !!@cov
+      end
+
+      # position: req_0
+      # type: union_1
+      def log(position)
+        return unless running?
+
+        cov << position.to_sym
+      end
+
+      def cov
+        @cov or raise
+      end
+
+      def show(io)
+        return unless running?
+
+        writer = Writer.new(@method_type, cov)
+        writer.write(io)
+      end
+
+      def new_type_with_log(position, type)
+        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)
+        when ::RBS::Types::Union
+          i = Random.rand(type.types.length)
+          new_type_with_log("#{position}_union_#{i}", type.types[i])
+        when ::RBS::Types::Optional
+          if Random.rand(2).zero?
+            new_type_with_log("#{position}_optional_left", type.type)
+          else
+            new_type_with_log("#{position}_optional_right", ::RBS::Types::Bases::Nil.new(location: nil))
+          end
+        else
+          log(position)
+          Type.new(type)
+        end
+      end
+    end
+  end
+end

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,44 +24,64 @@ 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.map { |v| to_symbolic_call_recursive(v, size: size) }
       else
-        type.to_symbolic_call(size:)
+        type.to_symbolic_call(size: size)
       end
     end
 
     def build_args_type
-      reqs = @fun.required_positionals.map { |param| Type.new(param.type) }
-      tras = @fun.trailing_positionals.map { |param| Type.new(param.type) }
-      sampled_optional_positionals = @fun.optional_positionals.take(Random.rand(@fun.optional_positionals.length + 1))
-      opts = sampled_optional_positionals.map { |param| Type.new(param.type) }
+      reqs = @fun.required_positionals.map.with_index do |param, i|
+        build_type_with_coverage("req_#{i}", param)
+      end
+
+      take_num = Random.rand(@fun.optional_positionals.length + 1)
+      opts = @fun.optional_positionals.take(take_num).map.each_with_index do |param, i|
+        build_type_with_coverage("opt_#{i}", param)
+      end
+
       rest = []
-      if (param = @fun.rest_positionals)
-        rest = Array.new(Random.rand(0..3)) { Type.new(param.type) }
+      if (rest_param = @fun.rest_positionals)
+        rest = Array.new(Random.rand(4)) do
+          build_type_with_coverage("rest", rest_param)
+        end
+      end
+
+      tras = @fun.trailing_positionals.map.with_index do |param, i|
+        build_type_with_coverage("trail_#{i}", param)
       end
+
       [reqs, opts, rest, tras].flatten
     end
 
     def build_kwargs_type
-      reqs = @fun.required_keywords.transform_values { |param| Type.new(param.type) }
+      reqs = @fun.required_keywords.keys.to_h do |key|
+        [key, build_type_with_coverage("keyreq_#{key}", @fun.required_keywords[key])]
+      end
       rand = Random.rand(@fun.optional_keywords.length + 1)
-      opts = @fun.optional_keywords.to_a.sample(rand).to_h { |name, param| [name, Type.new(param.type)] }
+      opts = @fun.optional_keywords.to_a.sample(rand).to_h do |key, param|
+        [key, build_type_with_coverage("key_#{key}", param)]
+      end
       kwargs = reqs.to_h.merge(opts)
       if (param = @fun.rest_keywords)
-        keys = Array.new(Random.rand(0..3)) do
+        keys = Array.new(Random.rand(4)) do
           random_key = nil
           loop do
             # @type var random_key: Symbol
             random_key = Type.new("Symbol").pick(size: 6)
             break unless kwargs.key?(random_key)
           end
-          [random_key, Type.new(param.type)]
+          [random_key, build_type_with_coverage("keyrest", param)]
         end
         kwargs.merge!(keys.to_h)
       end
       kwargs
     end
+
+    def build_type_with_coverage(position, param)
+      Coverage.new_type_with_log(position, param.type)
+    end
   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
@@ -55,8 +55,8 @@ module RaaP
         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)
@@ -67,8 +67,9 @@ module RaaP
           begin
             return_value = symbolic_caller.eval
           rescue StandardError, NotImplementedError
-            check = [:success]
             return_value = Value::Bottom.new
+            coverage("return", return_value, return_type)
+            check = [:success]
           rescue Timeout::ExitException
             raise
           rescue Exception => e # rubocop:disable Lint/RescueException
@@ -77,25 +78,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 +104,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:)
@@ -113,6 +114,7 @@ module RaaP
         if BindCall.is_a?(return_type, ::RBS::Types::ClassSingleton)
           # ::RBS::Test::TypeCheck cannot support to check singleton class
           if receiver_value == return_value
+            coverage("return", return_value, return_type)
             [:success]
           else
             [:failure]
@@ -126,8 +128,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,
@@ -135,6 +137,7 @@ module RaaP
       )
       begin
         if type_check.value(return_value, return_type)
+          coverage("return", return_value, return_type, type_check)
           [:success]
         else
           [:failure]
@@ -148,5 +151,33 @@ module RaaP
     def return_type
       @method_type.rbs.type.return_type
     end
+
+    def coverage(position, return_value, return_type, type_check = nil)
+      return unless Coverage.running?
+
+      case return_type
+      when ::RBS::Types::Tuple
+        return_type.types.zip(return_value).each_with_index do |(type, value), i|
+          if type_check&.value(value, type)
+            coverage("#{position}_tuple_#{i}", value, type, type_check)
+          end
+        end
+      when ::RBS::Types::Union
+        return_type.types.each_with_index do |type, i|
+          if type_check&.value(return_value, type)
+            coverage("#{position}_union_#{i}", return_value, type, type_check)
+            break
+          end
+        end
+      when ::RBS::Types::Optional
+        if return_value.nil?
+          Coverage.log("#{position}_optional_right")
+        else
+          coverage("#{position}_optional_left", return_value, return_type.type, type_check)
+        end
+      else
+        Coverage.log(position)
+      end
+    end
   end
 end