raap 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11be72cf2761c092ecbbcb59c5fd6d63de28d5c469b08595788cd62d27ba65c3
-  data.tar.gz: 2dc754b684cca3752177f0a5d1ef12ae3126d6ae7b32e07664e639fa27037f8a
+  metadata.gz: 508a0205dd03919d714a256f88193ab5755dd4d97c1cde9a5b0cb1720eae6b78
+  data.tar.gz: 8b220e18757b06c77816d27fd49b2e6db958b55c3d804890bc8691c23f2e74f7
 SHA512:
-  metadata.gz: 8dcca8c7c5aa10b0cd611a60c38a84bf4db1915cd049d701f068836488b748b653bd0a811d606c943754c0b4e72367d8e9255c06cdf0ab0f398bd3da3ce5357e
-  data.tar.gz: 3f2e7d3947ed5fbc02496b0f5437d100d6e6ba9cf8fd60c28b522d49f867c955b72a287d1845186346a377047acfed7d9944e6ef80d0dec1491235c3da9bf203
+  metadata.gz: 69cf2e9fa5b033a71c7ce3efd01c04be95d7ac9baf8a9d05f4c6e4e63ffbb8ff06f3cc857cce786bbc5adb7059e19eeaa05ae7026990afd22b7481b20cdcc09b
+  data.tar.gz: fe81a27af6cb732096635b12301a726b13d0ea8e1f0ea8301ec29a2978b17a41f4fced40a5d8821caa3129ed56c79e6084ed74bafe8d5e84e6f1dd6d34be4e97

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [1.1.0] - 2025-01-13
+
+* Bundle update by @ksss in https://github.com/ksss/raap/pull/31
+* Fix typing by @ksss in https://github.com/ksss/raap/pull/44
+* Support RBS v3.8 by @ksss in https://github.com/ksss/raap/pull/45
+* Use ruby34 by @ksss in https://github.com/ksss/raap/pull/46
+
 ## [1.0.0] - 2024-08-23
 
 * Do not modify array for RBS::Types::ClassInstance#args by @pocke in https://github.com/ksss/raap/pull/25

data/lib/raap/cli.rb

@@ -13,6 +13,7 @@ module RaaP
       :size_by,
       :allow_private,
       :coverage,
+      :numeric_positive,
       keyword_init: true
     )
 
@@ -44,6 +45,7 @@ module RaaP
         size_by: 1,
         coverage: true,
         allow_private: false,
+        numeric_positive: false,
       )
       @argv = argv
       @skip = DEFAULT_SKIP.dup
@@ -87,6 +89,9 @@ module RaaP
         o.on('--[no-]coverage', "Show coverage for RBS (default: #{@option.coverage})") do |arg|
           @option.coverage = arg
         end
+        o.on('--numeric-positive', "Generate positive numeric only (default: #{@option.numeric_positive})") do |arg|
+          @option.numeric_positive = arg
+        end
       end.parse!(@argv)
 
       self
@@ -110,18 +115,20 @@ module RaaP
       end
       @skip.freeze
 
+      Type::Arithmetic.numeric_positive = @option.numeric_positive
+
       @argv.each do |tag|
         next if tag.start_with?('!')
 
         case
         when tag.include?('#')
-          run_by(kind: :instance, tag: tag)
+          run_by(kind: :instance, tag:)
         when tag.include?('.')
-          run_by(kind: :singleton, tag: tag)
+          run_by(kind: :singleton, tag:)
         when tag.end_with?('*')
-          run_by_type_name_with_search(tag: tag)
+          run_by_type_name_with_search(tag:)
         else
-          run_by_type_name(tag: tag)
+          run_by_type_name(tag:)
         end
       end
 
@@ -195,10 +202,15 @@ module RaaP
 
       RaaP.logger.info("# #{type}")
       @results << {
-        method: method,
-        properties: method.method_types.map do |method_type|
-          property(receiver_type: receiver_type, type_params_decl: type_params_decl, type_args: type_args, method_type: method_type,
-                   method_name: method_name)
+        method:,
+        properties: method.defs.map do |type_def|
+          property(
+            receiver_type:,
+            type_params_decl:,
+            type_args:,
+            type_def:,
+            method_name:
+          )
         end
       }
     end
@@ -236,10 +248,15 @@ module RaaP
 
         RaaP.logger.info("# #{type_name}.#{method_name}")
         @results << {
-          method: method,
-          properties: method.method_types.map do |method_type|
-            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)
+          method:,
+          properties: method.defs.map do |type_def|
+            property(
+              receiver_type: Type.new("singleton(#{type.name})"),
+              type_params_decl:,
+              type_args:,
+              type_def:,
+              method_name:
+            )
           end
         }
       end
@@ -256,16 +273,21 @@ module RaaP
 
         RaaP.logger.info("# #{type_name}##{method_name}")
         @results << {
-          method: method,
-          properties: method.method_types.map do |method_type|
-            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)
+          method:,
+          properties: method.defs.map do |type_def|
+            property(
+              receiver_type: Type.new(type.name),
+              type_params_decl:,
+              type_args:,
+              type_def:,
+              method_name:
+            )
           end
         }
       end
     end
 
-    def property(receiver_type:, type_params_decl:, type_args:, method_type:, method_name:)
+    def property(receiver_type:, type_params_decl:, type_args:, type_def:, method_name:)
       rtype = __skip__ = receiver_type.type
       if receiver_type.type.instance_of?(::RBS::Types::ClassSingleton)
         prefix = 'self.'
@@ -278,19 +300,19 @@ module RaaP
         args = type_params_decl.map.with_index do |param, i|
           type_args[i] || param.upper_bound || ::RBS::Types::Bases::Any.new(location: nil)
         end
-        rtype = ::RBS::Types::ClassInstance.new(name: rtype.name, args: args, location: rtype.location)
+        rtype = ::RBS::Types::ClassInstance.new(name: rtype.name, args:, location: rtype.location)
         receiver_type = Type.new(rtype)
       end
-      RaaP.logger.info("## def #{prefix}#{method_name}: #{method_type}")
+      RaaP.logger.info("## def #{prefix}#{method_name}: #{type_def.type}")
       status = 0
       reason = nil
       prop = MethodProperty.new(
-        receiver_type: receiver_type,
-        method_name: method_name,
+        receiver_type:,
+        method_name:,
         method_type: MethodType.new(
-          method_type,
-          type_params_decl: type_params_decl,
-          type_args: type_args,
+          type_def.type,
+          type_params_decl:,
+          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),
@@ -298,8 +320,9 @@ module RaaP
         size_step: @option.size_from.step(to: @option.size_to, by: @option.size_by),
         timeout: @option.timeout,
         allow_private: @option.allow_private,
+        annotations: type_def.annotations
       )
-      RaaP::Coverage.start(method_type) if @option.coverage
+      RaaP::Coverage.start(type_def.type) if @option.coverage
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       stats = prop.run do |called|
         case called
@@ -314,8 +337,12 @@ module RaaP
           end
           RaaP.logger.debug { PP.pp(f.symbolic_call, ''.dup) }
           reason = StringIO.new
-          reason.puts "Failed in case of `#{f.called_str}`"
-          reason.puts
+          begin
+            reason.puts "Failed in case of `#{f.called_str}`"
+            reason.puts
+          rescue => e
+            RaaP.logger.debug { "Raised `#{e}` in Result::Failure" }
+          end
           reason.puts "### Repro"
           reason.puts
           reason.puts "```rb"
@@ -351,7 +378,7 @@ module RaaP
         reason.puts "Never succeeded => #{stats_log}"
       end
 
-      [status, method_name, method_type, reason]
+      [status, method_name, type_def.type, reason]
     end
   end
 end

data/lib/raap/function_type.rb

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

data/lib/raap/method_property.rb

@@ -8,13 +8,14 @@ module RaaP
       end
     end
 
-    def initialize(receiver_type:, method_name:, method_type:, size_step:, timeout:, allow_private: false)
+    def initialize(receiver_type:, method_name:, method_type:, size_step:, timeout:, allow_private: false, annotations: [])
       @receiver_type = receiver_type
       @method_name = method_name
       @method_type = method_type
       @size_step = size_step
       @timeout = timeout
       @allow_private = allow_private
+      @annotations = annotations
     end
 
     def run
@@ -23,7 +24,7 @@ module RaaP
         Timeout.timeout(@timeout) do
           catch(:break) do
             @size_step.each do |size|
-              call(size: size, stats: stats).tap do |ret|
+              call(size:, stats:).tap do |ret|
                 case ret
                 when Result::Success
                   stats.success += 1
@@ -55,8 +56,8 @@ module RaaP
         stats.break = true
         throw :break
       end
-      receiver_value = @receiver_type.to_symbolic_call(size: size)
-      args, kwargs, block = @method_type.arguments_to_symbolic_call(size: size)
+      receiver_value = @receiver_type.to_symbolic_call(size:)
+      args, kwargs, block = @method_type.arguments_to_symbolic_call(size:)
       # @type var symbolic_call: symbolic_call
       symbolic_call = [:call, receiver_value, @method_name, args, kwargs, block]
       symbolic_caller = SymbolicCaller.new(symbolic_call, allow_private: @allow_private)
@@ -78,23 +79,23 @@ module RaaP
           end
         else
           return_value = symbolic_caller.eval
-          check = check_return(receiver_value: receiver_value, return_value: return_value)
+          check = check_return(receiver_value:, return_value:)
         end
         case check
         in [:success]
-          Result::Success.new(symbolic_call: symbolic_call, return_value: return_value)
+          Result::Success.new(symbolic_call:, return_value:)
         in [:failure]
-          Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value)
+          Result::Failure.new(symbolic_call:, return_value:)
         in [:exception, exception]
-          Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
+          Result::Exception.new(symbolic_call:, exception:)
         end
       rescue TypeError => exception
-        Result::Failure.new(symbolic_call: symbolic_call, return_value: return_value, exception: exception)
+        Result::Failure.new(symbolic_call:, return_value:, exception:)
       end
 
     # not ensure symbolic_call
     rescue NoMethodError, NotImplementedError => exception
-      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue NameError => e
       RaaP.logger.warn("[#{e.class}] #{e.detailed_message}")
       msg = e.name.nil? ? '' : "for `#{BindCall.to_s(e.receiver)}::#{e.name}`"
@@ -104,23 +105,17 @@ module RaaP
       throw :break
     rescue SystemStackError => exception
       RaaP.logger.info "Found recursive type definition."
-      Result::Skip.new(symbolic_call: symbolic_call, exception: exception)
+      Result::Skip.new(symbolic_call:, exception:)
     rescue => exception
-      Result::Exception.new(symbolic_call: symbolic_call, exception: exception)
+      Result::Exception.new(symbolic_call:, exception:)
     end
 
     def check_return(receiver_value:, return_value:)
-      if BindCall.is_a?(receiver_value, Module)
-        if BindCall.is_a?(return_type, ::RBS::Types::ClassSingleton)
-          # ::RBS::Test::TypeCheck cannot support to check singleton class
-          if receiver_value == return_value
-            coverage("return", return_value, return_type)
-            [:success]
-          else
-            [:failure]
-          end
-        end
+      if implicitly_returns_nil? && BindCall.is_a?(return_value, NilClass)
+        return [:success]
+      end
 
+      if BindCall.is_a?(receiver_value, Module)
         self_class = receiver_value
         instance_class = receiver_value
       else
@@ -128,8 +123,8 @@ module RaaP
         instance_class = BindCall.class(receiver_value)
       end
       type_check = ::RBS::Test::TypeCheck.new(
-        self_class: self_class,
-        instance_class: instance_class,
+        self_class:,
+        instance_class:,
         class_class: Module,
         builder: RBS.builder,
         sample_size: 100,
@@ -148,6 +143,12 @@ module RaaP
       end
     end
 
+    def implicitly_returns_nil?
+      @annotations.any? do |a|
+        a.string == "implicitly-returns-nil"
+      end
+    end
+
     def return_type
       @method_type.rbs.type.return_type
     end

data/lib/raap/method_type.rb

@@ -19,7 +19,7 @@ module RaaP
 
       params = (type_params_decl + rbs.type_params).uniq
       ts = TypeSubstitution.new(params, type_args)
-      @rbs = ts.method_type_sub(rbs, self_type: self_type, instance_type: instance_type, class_type: class_type)
+      @rbs = ts.method_type_sub(rbs, self_type:, instance_type:, class_type:)
       function_or_untypedfunction = __skip__ = @rbs.type
       @fun_type = FunctionType.new(function_or_untypedfunction)
       @type_check = ::RBS::Test::TypeCheck.new(
@@ -33,12 +33,12 @@ module RaaP
     end
 
     def pick_arguments(size: 10)
-      SymbolicCaller.new(arguments_to_symbolic_call(size: size)).eval
+      SymbolicCaller.new(arguments_to_symbolic_call(size:)).eval
     end
 
     def arguments_to_symbolic_call(size: 10)
-      args, kwargs = @fun_type.arguments_to_symbolic_call(size: size)
-      block = pick_block(size: size)
+      args, kwargs = @fun_type.arguments_to_symbolic_call(size:)
+      block = pick_block(size:)
 
       [args, kwargs, block]
     end
@@ -62,7 +62,7 @@ module RaaP
         end
         fun.optional_positionals.each do |param|
           resource.shift.tap do |name|
-            default = Type.new(param.type).pick(size: size)
+            default = Type.new(param.type).pick(size:)
             args_name << name
             # FIXME: Support any object
             args_source << "#{name} = #{default.inspect}"
@@ -82,7 +82,7 @@ module RaaP
         end
       end
       # Hack: Use local variable in eval
-      fixed_return_value = Type.new(block.type.return_type).pick(size: size)
+      fixed_return_value = Type.new(block.type.return_type).pick(size:)
       _ = fixed_return_value
       type_check = @type_check
       _ = type_check

data/lib/raap/minitest.rb

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

data/lib/raap/type.rb

@@ -7,8 +7,18 @@ module RaaP
   # Type.new("Array[Integer]") { sized { |size| Array.new(size + 1) { integer.pick(size: size) } } }
   class Type
     module Arithmetic
+      def self.numeric_positive=(bool)
+        @numeric_positive = bool
+      end
+
       def self.float
-        positive_float.then { |x| [x, -x].sample or raise }
+        positive_float.then do |x|
+          if @numeric_positive
+            x
+          else
+            [x, -x].sample or raise
+          end
+        end
       end
 
       def self.positive_float
@@ -50,24 +60,29 @@ module RaaP
         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)
+        method_type = MethodType.new(
+          maped_rbs_method_type,
+          class_type: ::RBS::Types::ClassSingleton.new(name: type.name, location: nil),
+          instance_type: type,
+          self_type: type
+        )
 
         begin
-          args, kwargs, block = method_type.arguments_to_symbolic_call(size: size)
+          args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
           [:call, base, :new, args, kwargs, block]
         rescue
           $stderr.puts "Fail with `#{rbs_method_type}`"
           raise
         end
       else
-        [:call, Value::Module, :new, [type.to_s], { size: size }, nil]
+        [:call, Value::Module, :new, [type.to_s], { size: }, nil]
       end
     end
 
     # Special class case
     register("::Array") do
       instance = __skip__ = type
-      t = instance.args[0] ? Type.new(instance.args[0], range: range) : Type.random
+      t = instance.args[0] ? Type.new(instance.args[0], range:) : Type.random
       array(t)
     end
     register("::Binding") { binding }
@@ -104,7 +119,7 @@ module RaaP
     register("::NilClass") { nil }
     register("::Proc") { Proc.new {} }
     register("::Rational") { rational }
-    register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
+    register("::Regexp") { sized { |size| Regexp.new(string.pick(size:)) } }
     register("::String") { string }
     register("::Struct") { Struct.new(:foo, :bar).new }
     register("::Symbol") { symbol }
@@ -140,11 +155,11 @@ module RaaP
     end
 
     def pick(size: 10)
-      to_symbolic_caller(size: size).eval
+      to_symbolic_caller(size:).eval
     end
 
     def to_symbolic_caller(size: 10)
-      SymbolicCaller.new(to_symbolic_call(size: size))
+      SymbolicCaller.new(to_symbolic_call(size:))
     end
 
     def to_symbolic_call(size: 10)
@@ -153,20 +168,20 @@ module RaaP
 
       case type
       when ::RBS::Types::Tuple
-        type.types.map { |t| Type.new(t).to_symbolic_call(size: size) }
+        type.types.map { |t| Type.new(t).to_symbolic_call(size:) }
       when ::RBS::Types::Union
-        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size: size) }
+        type.types.sample&.then { |t| Type.new(t).to_symbolic_call(size:) }
       when ::RBS::Types::Intersection
         if type.free_variables.empty?
-          [:call, Value::Intersection, :new, [type.to_s], { size: size }, nil]
+          [:call, Value::Intersection, :new, [type.to_s], { size: }, nil]
         else
-          [:call, Value::Intersection, :new, [type], { size: size }, nil]
+          [:call, Value::Intersection, :new, [type], { size: }, nil]
         end
       when ::RBS::Types::Interface
         if type.free_variables.empty?
-          [:call, Value::Interface, :new, [type.to_s], { size: size }, nil]
+          [:call, Value::Interface, :new, [type.to_s], { size: }, nil]
         else
-          [:call, Value::Interface, :new, [type], { size: size }, nil]
+          [:call, Value::Interface, :new, [type], { size: }, nil]
         end
       when ::RBS::Types::Variable
         [:call, Value::Variable, :new, [type.to_s], {}, nil]
@@ -184,7 +199,7 @@ 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: size)
+        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size:)
         end
       when ::RBS::Types::Bases::Class
         RaaP.logger.warn("Unresolved `class` type, use Object instead.")
@@ -198,19 +213,19 @@ module RaaP
         Object.const_get(type.name.to_s)
       when ::RBS::Types::ClassInstance
         case gen = GENERATORS[type.name.absolute!.to_s]
-        in Proc then pick_by_generator(gen, size: size)
-        in nil then to_symbolic_call_from_initialize(type, size: size)
+        in Proc then pick_by_generator(gen, size:)
+        in nil then to_symbolic_call_from_initialize(type, 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: size) }
+        Proc.new { Type.new(type.type.return_type).to_symbolic_call(size:) }
       when ::RBS::Types::Literal
         type.literal
       when ::RBS::Types::Bases::Bool
         bool
       when ::RBS::Types::Bases::Any
-        Type.random.to_symbolic_call(size: size)
+        Type.random.to_symbolic_call(size:)
       when ::RBS::Types::Bases::Nil
         nil
       else
@@ -224,7 +239,7 @@ module RaaP
       ret = instance_exec(&gen)
       case ret
       when Sized
-        ret.pick(size: size)
+        ret.pick(size:)
       else
         ret
       end
@@ -233,7 +248,7 @@ module RaaP
     def to_symbolic_call_from_initialize(type, size:)
       type_name = type.name.absolute!
       const = Object.const_get(type_name.to_s)
-      Type.call_new_from(const, type, size: size)
+      Type.call_new_from(const, type, size:)
     end
 
     def parse(type)
@@ -248,7 +263,7 @@ module RaaP
     end
 
     def integer
-      sized { |size| float.pick(size: size).round }
+      sized { |size| float.pick(size:).round }
     end
 
     def none_zero_integer
@@ -272,16 +287,16 @@ module RaaP
 
     def rational
       sized do |size|
-        a = integer.pick(size: size)
-        b = none_zero_integer.pick(size: size)
+        a = integer.pick(size:)
+        b = none_zero_integer.pick(size:)
         [:call, Kernel, :Rational, [a, b], {}, nil]
       end
     end
 
     def complex
       sized do |size|
-        a = integer.pick(size: size)
-        b = none_zero_integer.pick(size: size)
+        a = integer.pick(size:)
+        b = none_zero_integer.pick(size:)
         [:call, Kernel, :Complex, [a, b], {}, nil]
       end
     end
@@ -306,13 +321,13 @@ module RaaP
 
     def symbol
       sized do |size|
-        string.pick(size: size).to_sym
+        string.pick(size:).to_sym
       end
     end
 
     def array(type)
       sized do |size|
-        Array.new(integer.pick(size: size).abs) do
+        Array.new(integer.pick(size:).abs) do
           type.to_symbolic_call(size: size / 2)
         end
       end
@@ -323,7 +338,7 @@ module RaaP
     def dict(key_type, value_type)
       sized do |size|
         csize = size / 2
-        Array.new(integer.pick(size: size).abs).to_h do
+        Array.new(integer.pick(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

@@ -31,8 +31,8 @@ module RaaP
 
       ::RBS::MethodType.new(
         type_params: [],
-        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) },
+        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:) },
         location: method_type.location
       )
     end
@@ -53,7 +53,7 @@ module RaaP
         when ::RBS::Types::Bases::Class
           class_type || ty
         else
-          sub(ty, self_type: self_type, instance_type: instance_type, class_type: class_type)
+          sub(ty, self_type:, instance_type:, class_type:)
         end
       end
     end

data/lib/raap/value/interface.rb

@@ -20,21 +20,21 @@ module RaaP
             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)
+            subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
 
             BindCall.define_method(base_mod, name) do |*_, &b|
               @fixed_return_value ||= {} #: Hash[Symbol, Interface | Type]
               @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)
+                                              Type.new(subed_method_type.type.return_type).pick(size:)
                                             end
               # @type var b: Proc?
               if b && subed_method_type.block && subed_method_type.block.type.is_a?(::RBS::Types::Function)
                 @fixed_block_arguments ||= {} #: Hash[Symbol, Array[FunctionType]]
                 @fixed_block_arguments[name] ||= size.times.map do
                   FunctionType.new(subed_method_type.block.type, coverage: false)
-                              .pick_arguments(size: size)
+                              .pick_arguments(size:)
                 end
 
                 @fixed_block_arguments[name].each do |a, kw|
@@ -48,10 +48,10 @@ module RaaP
 
         def new(type, size: 3)
           temp_class = ::Class.new(Interface) do |c|
-            define_method_from_interface(c, type, size: size)
+            define_method_from_interface(c, type, size:)
           end
           instance = temp_class.allocate
-          instance.__send__(:initialize, type, size: size)
+          instance.__send__(:initialize, type, size:)
           instance
         end
       end

data/lib/raap/value/intersection.rb

@@ -27,12 +27,12 @@ module RaaP
           type.types.each do |t|
             case t
             when ::RBS::Types::Interface
-              Interface.define_method_from_interface(self, t, size: size)
+              Interface.define_method_from_interface(self, t, size:)
             end
           end
         end
         type = ::RBS::Types::ClassInstance.new(name: ::RBS::TypeName.parse(base.name), args: [], location: nil)
-        SymbolicCaller.new(Type.call_new_from(c, type, size: size)).eval
+        SymbolicCaller.new(Type.call_new_from(c, type, size:)).eval
       end
     end
   end

data/lib/raap/value/module.rb

@@ -35,7 +35,7 @@ module RaaP
                          if !ts.include?('::BasicObject') || ts.any? { |t| t.split('::').last&.start_with?('_') }
                            ts.unshift('Object')
                          end
-                         Type.new(ts.uniq.join(' & ')).pick(size: size)
+                         Type.new(ts.uniq.join(' & ')).pick(size:)
                        end
                      end
         const = ::Object.const_get(@type.name.absolute!.to_s)

data/lib/raap/version.rb

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

data/lib/shims.rb

@@ -48,8 +48,8 @@ unless RBS::TypeName.singleton_class.method_defined?(:parse)
         raise unless name
 
         TypeName.new(
-          name: name,
-          namespace: RBS::Namespace.new(path: path, absolute: absolute)
+          name:,
+          namespace: RBS::Namespace.new(path:, absolute:)
         )
       end
     end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raap
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - ksss
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-01-12 00:00:00.000000000 Z
+date: 2025-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rbs
@@ -80,7 +79,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,8 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: RBS as a Property
 test_files: []