raap 0.1.0

data/lib/raap/type.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module RaaP
+  # Type.new("Integer").pick(size: 10) #=> 2
+  # Type.new("Symbol").pick(size: 6) #=> :abcdef
+  # Type.new("Array[Integer]").pick(size: 3) #=> [1, 2, 3]
+  # Type.new("Array[Integer]") { sized { |size| Array.new(size + 1) { integer.pick(size: size) } } }
+  class Type
+    module Arithmetic
+      def self.float
+        positive_float.then { |x| [x, -x].sample or raise }
+      end
+
+      def self.positive_float
+        x = Random.rand
+        x / Math.sqrt(1 - x * x)
+      end
+    end
+
+    GENERATORS = {}
+    SIMPLE_SOURCE = ('a'..'z').to_a << '_'
+    RECURSION = Hash.new { |h, k| h[k] = { count: 0, logged: false } }
+
+    # Type.register "::Integer::positive" { sized { |size| size } }
+    def self.register(type_name, &block)
+      GENERATORS[type_name] = block
+    end
+
+    # Special class case
+    register("::Array") do
+      t = type.args[0] || 'untyped'
+      array(Type.new(t, range: range))
+    end
+    register("::Binding") { sized { binding } }
+    register("::Complex") { complex }
+    register("::Data") { sized { Data.define } }
+    register("::Encoding") { encoding }
+    register("::FalseClass") { sized { false } }
+    register("::Float") { float }
+    register("::Hash") do
+      sized do |size|
+        Array.new(integer.pick(size: size).abs).to_h do
+          k = type.args[0] || 'untyped'
+          v = type.args[1] || 'untyped'
+          [Type.new(k).pick(size: size), Type.new(v).pick(size: size)]
+        end
+      end
+    end
+    register("::Integer") { integer }
+    register("::IO") { sized { $stdout } }
+    register("::Method") { sized { temp_method_object } }
+    register("::NilClass") { sized { nil } }
+    register("::Proc") { sized { Proc.new {} } }
+    register("::Rational") { rational }
+    register("::Regexp") { sized { |size| Regexp.new(string.pick(size: size)) } }
+    register("::String") { string }
+    register("::Struct") { sized { Struct.new(:foo, :bar).new } }
+    register("::Symbol") { symbol }
+    register("::Time") { sized { Time.now } }
+    register("::TrueClass") { sized { true } }
+    register("::UnboundMethod") { sized { temp_method_object.unbind } }
+
+    attr_reader :type
+    attr_reader :range
+
+    def initialize(type, range: nil..nil)
+      @type = parse(type)
+      @range = range
+    end
+
+    def sized(&block)
+      Sized.new(&block)
+    end
+
+    def pick(size: 10, eval: true)
+      symb = to_symbolic_call(size:)
+      eval ? SymbolicCaller.new(symb).eval : symb
+    end
+
+    def to_symbolic_call(size: 10)
+      raise TypeError, "size should be Integer" unless size.is_a?(Integer)
+      raise ArgumentError, "negative size" if size.negative?
+
+      case type
+      when ::RBS::Types::Tuple
+        type.types.map { |t| Type.new(t).pick(size:) }
+      when ::RBS::Types::Union
+        type.types.sample&.then { |t| Type.new(t).pick(size:) }
+      when ::RBS::Types::Intersection
+        Value::Intersection.new(type, size: size)
+      when ::RBS::Types::Optional
+        case Random.rand(2)
+        in 0 then Type.new(type.type).pick(size:)
+        in 1 then nil
+        end
+      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)).pick(size:)
+        end
+      when ::RBS::Types::Bases::Class
+        raise "cannot resolve `class` type"
+      when ::RBS::Types::Bases::Instance
+        raise "cannot resolve `instance` type"
+      when ::RBS::Types::Bases::Self
+        raise "cannot resolve `self` type"
+      when ::RBS::Types::Interface
+        Value::Interface.new(type, size: size)
+      when ::RBS::Types::Variable
+        Value::Variable.new(type)
+      when ::RBS::Types::ClassSingleton
+        Object.const_get(type.name.to_s)
+      when ::RBS::Types::ClassInstance
+        case gen = GENERATORS[type.name.absolute!.to_s]
+        when Proc then instance_exec(&gen).pick(size: size)
+        when nil then pick_from_initialize(type, size:)
+        end
+      when ::RBS::Types::Record
+        type.fields.transform_values { |t| Type.new(t).pick(size:) }
+      when ::RBS::Types::Proc
+        Proc.new { Type.new(type.type.return_type).pick(size:) }
+      when ::RBS::Types::Literal
+        type.literal
+      when ::RBS::Types::Bases::Bool
+        bool.pick(size: size)
+      when ::RBS::Types::Bases::Void
+        Value::Void.new
+      when ::RBS::Types::Bases::Any
+        untyped.pick(size: size)
+      when ::RBS::Types::Bases::Nil
+        nil
+      when ::RBS::Types::Bases::Top
+        Value::Top.new
+      when ::RBS::Types::Bases::Bottom
+        Value::Bottom.new
+      else
+        raise "not implemented #{type.to_s}"
+      end
+    end
+
+    def pick_from_initialize(type, size:)
+      type_name = type.name.absolute!
+      const = Object.const_get(type_name.to_s)
+      definition = RBS.builder.build_singleton(type_name)
+      snew = definition.methods[:new]
+      if snew
+        # class
+        rbs_method_type = snew.method_types.sample or raise
+        type_params = definition.type_params_decl.concat(rbs_method_type.type_params.drop(definition.type_params_decl.length))
+        ts = TypeSubstitution.new(type_params, type.args)
+        maped_rbs_method_type = rbs_method_type
+        maped_rbs_method_type = ts.method_type_sub(rbs_method_type)
+        method_type = MethodType.new(maped_rbs_method_type)
+
+        begin
+          try(times: 5, size: size) do |size|
+            args, kwargs, block = method_type.pick_arguments(size: size, eval: false)
+            [:call, const, :new, args, kwargs, block]
+          end
+        rescue
+          $stderr.puts "Fail with `#{rbs_method_type}`"
+          raise
+        end
+      else
+        Value::Module.new(type)
+      end
+    end
+
+    private
+
+    def parse(type)
+      case type
+      when String
+        RBS.parse_type(type) or raise "cannot parse #{type.inspect}"
+      when ::RBS::TypeName
+        parse(type.to_s)
+      else
+        type
+      end
+    end
+
+    def try(times:, size:)
+      # @type var error: Exception?
+      ret = error = nil
+      times.times do
+        ret = yield size
+        if ret
+          error = nil
+          break
+        end
+      rescue => e
+        size += 1
+        error = e
+        next
+      end
+
+      if error
+        $stderr.puts
+        $stderr.puts "=== Catch error when generating type `#{type}`. Please check your RBS or RaaP bug. ==="
+        $stderr.puts "(#{error.class}) #{error.message}"
+        raise error
+      end
+
+      ret
+    end
+
+    def integer
+      sized { |size| float.pick(size: size).round }
+    end
+
+    def none_zero_integer
+      integer.such_that { |i| i != 0 }
+    end
+
+    def float
+      sized do |size|
+        case [@range.begin, @range.end]
+        in nil, nil
+          Arithmetic.float * size
+        in nil, high
+          high - Arithmetic.positive_float * size
+        in low, nil
+          low + Arithmetic.positive_float * size
+        in low, high
+          Random.rand(Range.new(low.to_f, high.to_f, @range.exclude_end?))
+        end.round(2)
+      end
+    end
+
+    def rational
+      sized do |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: size)
+        b = none_zero_integer.pick(size: size)
+        [:call, Kernel, :Complex, [a, b], {}, nil]
+      end
+    end
+
+    def string
+      sized do |size|
+        if size == 0
+          +""
+        else
+          case [@range.begin, @range.end]
+          in nil, nil
+            size.times.map { SIMPLE_SOURCE.sample }.join
+          in nil, _
+            raise "Should set range.begin and range.end"
+          in _, nil
+            raise "Should set range.begin and range.end"
+          in s, e
+            a = (s..e).to_a
+            size.times.map { a.sample }.join
+          end
+        end
+      end
+    end
+
+    def symbol
+      sized do |size|
+        string.pick(size: size).to_sym
+      end
+    end
+
+    def array(type)
+      sized do |size|
+        Array.new(integer.pick(size: size).abs) do
+          type.pick(size: size)
+        end
+      end
+    end
+
+    def encoding
+      sized do
+        # @type block: RaaP::symbolic_call
+        e = Encoding.list.sample
+        [:call, Encoding, :find, [e.name], {} , nil]
+      end
+    end
+
+    def bool
+      sized { [true, false].sample }
+    end
+
+    def untyped
+      case Random.rand(5)
+      in 0 then integer
+      in 1 then float
+      in 2 then string
+      in 3 then symbol
+      in 4 then bool
+      in 5 then encoding
+      end
+    end
+
+    def temp_method_object
+      o = Object.new
+      m = 6.times.map { SIMPLE_SOURCE.sample }.join
+      o.define_singleton_method(m) { }
+      o.method(m)
+    end
+  end
+end

data/lib/raap/type_substitution.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RaaP
+  class TypeSubstitution
+    def initialize(type_params, type_args)
+      @type_params = type_params
+      @type_args = type_args
+    end
+
+    def build
+      bound_map = @type_params.zip(@type_args).to_h do |(bound, arg)|
+        if arg
+          [bound.name, arg]
+        elsif bound.upper_bound
+          [bound.name, bound.upper_bound]
+        else
+          [bound.name, ::RBS::Types::Bases::Top.new(location: nil)]
+        end
+      end
+      ::RBS::Substitution.build(bound_map.keys, bound_map.values)
+    end
+
+    def method_type_sub(method_type, self_type: nil, instance_type: nil, class_type: nil)
+      sub = build
+      ::RBS::MethodType.new(
+        type_params: [],
+        type: method_type.type.sub(sub).then { |ty| sub(ty, self_type:, instance_type:, class_type:) },
+        block: method_type.block&.sub(sub)&.then { |bl| sub(bl, self_type:, instance_type:, class_type:) },
+        location: method_type.location
+      )
+    end
+
+    private
+
+    def sub(search, self_type:, instance_type:, class_type:)
+      if self_type.nil? && instance_type.nil? && class_type.nil?
+        return search
+      end
+      search.map_type do |ty|
+        case ty
+        when ::RBS::Types::Bases::Self
+          self_type || ty
+        when ::RBS::Types::Bases::Instance
+          instance_type || ty
+        when ::RBS::Types::Bases::Class
+          class_type || ty
+        else
+          sub(ty, self_type:, instance_type:, class_type:)
+        end
+      end
+    end
+  end
+end

data/lib/raap/value/bottom.rb

@@ -0,0 +1,8 @@
+module RaaP
+  module Value
+    class Bottom < BasicObject
+      def inspect = "#<bot>"
+      def class = Bottom
+    end
+  end
+end

data/lib/raap/value/interface.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RaaP
+  module Value
+    class Interface < BasicObject
+      def initialize(type, size: 3, self_type: nil, instance_type: nil, class_type: nil)
+        @type = type.is_a?(::String) ? RBS.parse_type(type) : type
+        @size = size
+
+        definition = RBS.builder.build_interface(@type.name.absolute!)
+        definition.methods.each do |name, method|
+          method_type = method.method_types.sample or Kernel.raise
+          type_params = definition.type_params_decl.concat(method_type.type_params.drop(definition.type_params_decl.length))
+          ts = TypeSubstitution.new(type_params, @type.args)
+
+          subed_method_type = ts.method_type_sub(method_type, self_type:, instance_type:, class_type:)
+
+          BindCall.define_singleton_method(self, name) do |*, &b|
+            @fixed_return_value ||= Type.new(subed_method_type.type.return_type).pick(size: size)
+            if subed_method_type.block
+              @fixed_block_arguments ||= size.times.map do
+                fun_type = FunctionType.new(subed_method_type.block.type)
+                fun_type.pick_arguments(size: size)
+              end
+            else
+              @fixed_block_arguments = []
+            end
+            if b
+              unless subed_method_type.block
+                Kernel.raise "block of `#{@type.name}##{name}` was called. But block signature not defined."
+              end
+              @fixed_block_arguments.each do |a, kw|
+                b.call(*a, **kw)
+              end
+            end
+            @fixed_return_value
+          end
+        end
+      end
+
+      def class
+        Interface
+      end
+
+      def inspect
+        "#<interface @type=#{@type.to_s} @methods=#{RBS.builder.build_interface(@type.name.absolute!).methods.keys} @size=#{@size}>"
+      end
+    end
+  end
+end

data/lib/raap/value/intersection.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RaaP
+  module Value
+    class Intersection < BasicObject
+      def initialize(type, size:)
+        @type = type
+        @children = type.types.map { |t| Type.new(t).pick(size: size) }
+        @size = size
+      end
+
+      def inspect
+        "#<intersection @type=#{@type.to_s.inspect} @size=#{@size.inspect}>"
+      end
+
+      def class
+        Intersection
+      end
+
+      def method_missing(name, *args, **kwargs, &block)
+        @children.each do |child|
+          if BindCall.respond_to?(child, name)
+            return child.__send__(name, *args, **kwargs, &block)
+          end
+        end
+      end
+
+      def respond_to?(...)
+        @children.any? do |type|
+          BindCall.respond_to?(type, ...)
+        end
+      end
+    end
+  end
+end

data/lib/raap/value/module.rb

@@ -0,0 +1,17 @@
+module RaaP
+  module Value
+    # FIXME: consider self_types
+    class Module < BasicObject
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+        const = ::Object.const_get(type.name.absolute!.to_s)
+        BindCall.extend(self, const)
+      end
+
+      def inspect = "#<module #{@type}>"
+      def class = Value::Module
+    end
+  end
+end

data/lib/raap/value/top.rb

@@ -0,0 +1,8 @@
+module RaaP
+  module Value
+    class Top < BasicObject
+      def inspect = "#<top>"
+      def class = Top
+    end
+  end
+end

data/lib/raap/value/variable.rb

@@ -0,0 +1,14 @@
+module RaaP
+  module Value
+    class Variable < BasicObject
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def inspect = "#<var #{type}>"
+      def class = Variable
+    end
+  end
+end

data/lib/raap/value/void.rb

@@ -0,0 +1,8 @@
+module RaaP
+  module Value
+    class Void < BasicObject
+      def inspect = "#<void>"
+      def class = Void
+    end
+  end
+end

data/lib/raap/value.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RaaP
+  module Value
+    autoload :Bottom, "raap/value/bottom"
+    autoload :Interface, "raap/value/interface"
+    autoload :Intersection, "raap/value/intersection"
+    autoload :Module, "raap/value/module"
+    autoload :Top, "raap/value/top"
+    autoload :Variable, "raap/value/variable"
+    autoload :Void, "raap/value/void"
+  end
+end

data/lib/raap/version.rb

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

data/lib/raap.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'rbs'
+require 'rbs/cli'
+require 'rbs/test'
+require 'optparse'
+require 'timeout'
+require 'logger'
+
+require_relative 'raap/version'
+require_relative 'raap/value'
+
+module RaaP
+  class << self
+    attr_accessor :logger
+  end
+
+  self.logger = ::Logger.new($stdout)
+  self.logger.level = ::Logger::WARN
+
+  autoload :BindCall, "raap/bind_call"
+  autoload :CLI, "raap/cli"
+  autoload :FunctionType, "raap/function_type"
+  autoload :MethodProperty, "raap/method_property"
+  autoload :MethodType, "raap/method_type"
+  autoload :MethodValue, "raap/method_value"
+  autoload :RBS, "raap/rbs"
+  autoload :Result, "raap/result"
+  autoload :Sized, "raap/sized"
+  autoload :SymbolicCaller, "raap/symbolic_caller"
+  autoload :Type, "raap/type"
+  autoload :TypeSubstitution, "raap/type_substitution"
+  autoload :VERSION, "raap/version"
+end

data/rbs_collection.lock.yaml

@@ -0,0 +1,68 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: abbrev
+  version: '0'
+  source:
+    type: stdlib
+- name: fileutils
+  version: '0'
+  source:
+    type: stdlib
+- 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: be76a75932e8ed6ee91a95ba936cf88b674bf044
+    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: timeout
+  version: '0'
+  source:
+    type: stdlib
+- name: tsort
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,20 @@
+# 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
+    ignore: true
+  - name: steep
+    ignore: true