raap 0.5.0 → 0.7.0

data/lib/raap/method_type.rb

@@ -2,7 +2,7 @@
 
 module RaaP
   class MethodType
-    attr_reader :rbs
+    attr_reader :rbs, :original_rbs
 
     def initialize(method, type_params_decl: [], type_args: [], self_type: nil, instance_type: nil, class_type: nil)
       rbs =
@@ -20,17 +20,19 @@ 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:)
-      @fun_type = FunctionType.new(@rbs.type)
+      @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)
     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,8 +42,15 @@ 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:)
-      Proc.new { fixed_return_value }
+      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}")
+        end
+
+        Coverage.new_type_with_log("block_return", block.type.return_type)
+        fixed_return_value
+      end
     end
 
     def check_return(return_value)

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:)
+          args, kwargs, _block = method_type.pick_arguments(size: 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:) }
+          values = types.map { |t| t.pick(size: size) }
           assert yield(*values)
         end
       end

data/lib/raap/rbs.rb

@@ -26,6 +26,48 @@ module RaaP
       ::RBS::Parser.parse_method_type(method_type, require_eof: true) or raise
     end
 
+    def self.parse_member(member_type)
+      _, _, decls = ::RBS::Parser.parse_signature(<<~RBS)
+        module MemberScope
+          #{member_type}
+        end
+      RBS
+      decl = decls.first or raise
+      raise unless decl.is_a?(::RBS::AST::Declarations::Module)
+
+      member = decl.members.first or raise
+      raise unless member.is_a?(::RBS::AST::Members::Attribute)
+
+      member.tap do |m|
+        m = __skip__ = m
+        _shift_location(m.type, -m.location.start_pos)
+        _shift_location(m, -m.location.start_pos)
+      end
+    end
+
+    def self._shift_location(localable, shift)
+      return if localable.location.nil?
+
+      l = localable.instance_variable_get("@location")
+      localable.instance_variable_set(
+        "@location",
+        ::RBS::Location.new(
+          buffer: ::RBS::Buffer.new(
+            name: l.buffer.name,
+            content: l.buffer.content[-shift..l.end_pos],
+          ),
+          start_pos: l.start_pos + shift,
+          end_pos: l.end_pos + shift,
+        )
+      )
+      case localable
+      when ::RBS::Types::Union
+        localable.types.each { |t| _shift_location(t, shift) }
+      when ::RBS::Types::Optional
+        _shift_location(localable.type, shift)
+      end
+    end
+
     def self.find_alias_decl(type_name, method_name)
       env.class_decls[type_name].decls.each do |d|
         d.decl.members.each do |member|

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

@@ -24,6 +24,7 @@ module RaaP
     def self.register(type_name, &block)
       raise ArgumentError, "block is required" unless block
 
+      type_name = "::#{type_name}" if !type_name.start_with?("::")
       GENERATORS[type_name] = __skip__ = block
     end
 
@@ -52,28 +53,29 @@ module RaaP
         method_type = MethodType.new(maped_rbs_method_type)
 
         begin
-          args, kwargs, block = method_type.arguments_to_symbolic_call(size:)
+          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: }, nil]
+        [: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 } }
+    register("::Binding") { binding }
     register("::Complex") { complex }
-    register("::Data") { sized { Data.define } }
+    register("::Data") { Data.define }
     register("::Encoding") { encoding }
-    register("::FalseClass") { sized { false } }
+    register("::FalseClass") { false }
+    register("::File") { File.open("/dev/null") }
     register("::Float") { float }
     register("::Hash") do
       instance = __skip__ = type
@@ -82,18 +84,18 @@ module RaaP
       dict(key, value)
     end
     register("::Integer") { integer }
-    register("::IO") { sized { $stdout } }
-    register("::Method") { sized { temp_method_object } }
-    register("::NilClass") { sized { nil } }
-    register("::Proc") { sized { Proc.new {} } }
+    register("::IO") { $stdout }
+    register("::Method") { temp_method_object }
+    register("::NilClass") { nil }
+    register("::Proc") { 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("::Struct") { Struct.new(:foo, :bar).new }
     register("::Symbol") { symbol }
-    register("::Time") { sized { [:call, Time, :now, [], {}, nil] } }
-    register("::TrueClass") { sized { true } }
-    register("::UnboundMethod") { sized { temp_method_object.unbind } }
+    register("::Time") { [:call, Time, :now, [], {}, nil] }
+    register("::TrueClass") { true }
+    register("::UnboundMethod") { temp_method_object.unbind }
 
     attr_reader :type
     attr_reader :range
@@ -118,11 +120,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)
@@ -131,20 +133,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]
@@ -162,7 +164,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:)
+        in nil then Type.new(RBS.builder.expand_alias2(type.name, type.args)).to_symbolic_call(size: size)
         end
       when ::RBS::Types::Bases::Class
         RaaP.logger.warn("Unresolved `class` type, use Object instead.")
@@ -176,19 +178,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 instance_exec(&gen).pick(size:)
-        in nil then to_symbolic_call_from_initialize(type, size:)
+        in Proc then pick_by_generator(gen, 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
       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
@@ -198,10 +200,20 @@ module RaaP
 
     private
 
+    def pick_by_generator(gen, size:)
+      ret = instance_exec(&gen)
+      case ret
+      when Sized
+        ret.pick(size: size)
+      else
+        ret
+      end
+    end
+
     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:)
+      Type.call_new_from(const, type, size: size)
     end
 
     def parse(type)
@@ -216,7 +228,7 @@ module RaaP
     end
 
     def integer
-      sized { |size| float.pick(size:).round }
+      sized { |size| float.pick(size: size).round }
     end
 
     def none_zero_integer
@@ -240,16 +252,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
@@ -274,13 +286,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
@@ -291,7 +303,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)
@@ -301,16 +313,12 @@ module RaaP
     end
 
     def encoding
-      sized do
-        e = Encoding.list.sample or raise
-        [:call, Encoding, :find, [e.name], {}, nil]
-      end
+      e = Encoding.list.sample or raise
+      [:call, Encoding, :find, [e.name], {}, nil]
     end
 
     def bool
-      sized do
-        Random.rand(2) == 0
-      end
+      Random.rand(2) == 0
     end
 
     def temp_method_object

data/lib/raap/type_substitution.rb

@@ -25,10 +25,14 @@ module RaaP
       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
+      if sub.empty? && self_type.nil? && instance_type.nil? && class_type.nil?
+        return method_type
+      end
+
       ::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
@@ -49,7 +53,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/interface.rb

@@ -2,9 +2,9 @@
 
 module RaaP
   module Value
-    class Interface < BasicObject
+    class Interface
       class << self
-        def define_method_from_interface(base_class, type, size: 3)
+        def define_method_from_interface(base_mod, 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}"
@@ -20,26 +20,23 @@ 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:, instance_type:, class_type:)
+            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|
+            BindCall.define_method(base_mod, 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:)
+                                              Type.new(subed_method_type.type.return_type).pick(size: size)
                                             end
               # @type var b: Proc?
-              if b
+              if b && subed_method_type.block && subed_method_type.block.type.is_a?(::RBS::Types::Function)
                 @fixed_block_arguments ||= {}
-                @fixed_block_arguments[name] ||= if subed_method_type.block
-                                                   size.times.map do
-                                                     FunctionType.new(subed_method_type.block.type)
-                                                                 .pick_arguments(size:)
-                                                   end
-                                                 else
-                                                   []
-                                                 end
+                @fixed_block_arguments[name] ||= size.times.map do
+                  FunctionType.new(subed_method_type.block.type)
+                              .pick_arguments(size: size)
+                end
+
                 @fixed_block_arguments[name].each do |a, kw|
                   b.call(*a, **kw)
                 end
@@ -51,10 +48,10 @@ module RaaP
 
         def new(type, size: 3)
           temp_class = ::Class.new(Interface) do |c|
-            define_method_from_interface(c, type, size:)
+            define_method_from_interface(c, type, size: size)
           end
           instance = temp_class.allocate
-          instance.__send__(:initialize, type, size:)
+          instance.__send__(:initialize, type, size: size)
           instance
         end
       end
@@ -68,14 +65,6 @@ module RaaP
         @size = size
       end
 
-      def respond_to?(name, _include_all = false)
-        @definition.methods.has_key?(name.to_sym)
-      end
-
-      def class
-        Interface
-      end
-
       def inspect
         "#<interface @type=`#{@type}` @methods=#{@definition.methods.keys} @size=#{@size}>"
       end

data/lib/raap/value/intersection.rb

@@ -17,23 +17,22 @@ module RaaP
           raise ArgumentError, "intersection type must have at least one class instance type in `#{instances}`"
         end
 
-        base = instances.find { |c| c.is_a?(::Class) } || BasicObject
+        base = instances.find { |c| c.is_a?(::Class) } || Object
 
         c = Class.new(base) do
           instances.select { |i| !i.is_a?(::Class) }.each do |m|
             include(m)
           end
 
-          interfaces = type.types.select do |t|
-            t.instance_of?(::RBS::Types::Interface)
-          end
-
-          interfaces.each do |interface|
-            Interface.define_method_from_interface(self, interface, size:)
+          type.types.each do |t|
+            case t
+            when ::RBS::Types::Interface
+              Interface.define_method_from_interface(self, t, size: size)
+            end
           end
         end
         type = ::RBS::Types::ClassInstance.new(name: TypeName(base.name), args: [], location: nil)
-        SymbolicCaller.new(Type.call_new_from(c, type, size:)).eval
+        SymbolicCaller.new(Type.call_new_from(c, type, size: 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:)
+                         Type.new(ts.uniq.join(' & ')).pick(size: size)
                        end
                      end
         const = ::Object.const_get(@type.name.absolute!.to_s)

data/lib/raap/value/variable.rb

@@ -2,7 +2,7 @@
 
 module RaaP
   module Value
-    class Variable < BasicObject
+    class Variable
       attr_reader :type
 
       def initialize(type)

data/lib/raap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RaaP
-  VERSION = "0.5.0"
+  VERSION = "0.7.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
@@ -22,6 +23,7 @@ module RaaP
 
   autoload :BindCall, "raap/bind_call"
   autoload :CLI, "raap/cli"
+  autoload :Coverage, "raap/coverage"
   autoload :FunctionType, "raap/function_type"
   autoload :MethodProperty, "raap/method_property"
   autoload :MethodType, "raap/method_type"

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