rbs-dynamic 0.1.0

data/lib/rbs/dynamic/converter/trace_to_rbs.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "rbs"
+require_relative "../builder.rb"
+require_relative "../refine/each_called_method.rb"
+require_relative "./called_method_to_sigunature.rb"
+require_relative "./called_method_to_with_interface.rb"
+
+module RBS module Dynamic module Converter
+  class TraceToRBS
+    using RBS::Dynamic::Refine::EachCalledMethod
+    using RBS::Dynamic::Refine::TracePoint::ToRBSType
+    using CalledMethodToMethodSigunature
+    using CalledMethodToWithInterface
+
+    using Module.new {
+      refine Module do
+        def constants_wit_rbs_type(...)
+          constants(...)
+            # Except to ARGF.class
+            .filter_map { |name| [name, const_get(name).to_rbs_type.except_value] if const_get(name).class.name =~ /^\w+$/ }
+            .to_h
+        end
+
+        def include_prepend_modules
+          ancestors = Class === self ? self.ancestors.take_while { _1 != self.superclass } : self.ancestors
+          [ancestors.take_while { _1 != self }.reverse, ancestors.drop_while { _1 != self }.drop(1).reverse]
+        end
+
+        # M1::M2::X => [M1, M1::M2, M1::M2::X]
+        def namespace_paths
+          name.split("::").inject([]) { |result, scope|
+            result << Object.const_get("#{result.last}::#{scope}")
+          }
+        end
+      end
+    }
+
+    attr_reader :called_methods
+
+    def initialize(called_methods)
+      @called_methods = called_methods
+    end
+
+    def convert(
+      root_path: nil,
+      except_build_members: [],
+      include_method_location: false,
+      method_defined_calssses: %i(defined_class receiver_class),
+      use_literal_type: false,
+      with_literal_type: false,
+      use_interface: false,
+      use_interface_method_argument: false,
+      target_classname_pattern: /.*/,
+      ignore_classname_pattern: nil
+    )
+      called_methods_ = called_methods.each_called_method.reject { _1[:block?] }
+      klass_with_called_methods = [
+          if method_defined_calssses.include? :defined_class
+            called_methods_.group_by { _1[:receiver_defined_class] }
+          end,
+          if method_defined_calssses.include? :receiver_class
+            called_methods_.group_by { _1[:receiver_class] }
+          end
+        ]
+        .compact
+        .inject { |result, it| result.merge(it) { |key, a, b| a + b } }
+        .select { |klass, _| Module === klass }.reject { |klass, _| klass.nil? || klass.singleton_class? }
+        .to_h { |klass, called_methods|
+          [klass, called_methods.uniq { [_1[:method_id], _1[:arguments], _1[:return_value_class], _1[:called_path], _1[:called_lineno]] }.group_by { _1[:method_id] }]
+        }
+      klasses = klass_with_called_methods.keys
+
+      # Modules / classes that are defined but methods are not called are also defined in RBS
+      non_called_klass = klass_with_called_methods.keys.map { _1.namespace_paths }.flatten \
+                       + klasses.filter_map { Class === _1 && Object != _1.superclass && BasicObject != _1.superclass && _1.superclass } \
+                       - klasses
+
+      # non_called_klass += non_called_klass.map { _1.include_prepend_modules }.flatten
+      klass_with_called_methods = non_called_klass.to_h { [_1, {}] }.merge(klass_with_called_methods)
+      # klass_with_called_methods = klass_with_called_methods.merge(non_called_klass.to_h { [_1, {}] })
+
+      # klass_with_called_methods.sort_by { |klass, _| klass.name }.to_h { |klass, name_with_called_methods|
+      klass_with_called_methods
+        .select { |klass, _| target_classname_pattern && target_classname_pattern =~ klass.name }
+        .reject { |klass, _| ignore_classname_pattern && ignore_classname_pattern =~ klass.name }
+        .to_h { |klass, name_with_called_methods|
+        builder = Class === klass ? RBS::Dynamic::Builder::Class.new(klass) : RBS::Dynamic::Builder::Module.new(klass)
+
+        # Add prepend / include
+        # MEMO: Add only the traced module to RBS
+        # TODO: Predefined RBS modules (e.g. core module) other than Trace are not mixin
+        klass.include_prepend_modules.tap { |prepended, included|
+          # prepend
+          prepended.each { |mod|
+            builder.add_prepended_module(mod) if klasses.include? mod
+          } unless except_build_members.include? :prepended_modules
+
+          # include
+          included.each { |mod|
+            builder.add_inclued_module(mod) if klasses.include? mod
+          } unless except_build_members.include? :inclued_modules
+        }
+
+        # Add extend
+        klass.singleton_class.include_prepend_modules.flatten.each { |mod|
+          builder.add_extended_module(mod) if klasses.include? mod
+        } unless except_build_members.include? :extended_modules
+
+        # Add constant variable
+        klass.constants_wit_rbs_type(false).each { |name, type|
+          builder.add_constant_variable(name, type) if name == name.upcase
+        } unless except_build_members.include? :constant_variables
+
+        # Add instance variable
+        name_with_called_methods.map { |_, called_methods| called_methods.map { _1[:instance_variables_rbs_type] } }.flatten.each { |instance_variables_rbs_type|
+          instance_variables_rbs_type.each { |name, type|
+            # TODO: Support use_literal_type and with_literal_type
+            builder.add_instance_variable(name, type.except_value)
+          }
+        } unless except_build_members.include? :instance_variables
+
+        # Add method and singleton method
+        name_with_called_methods.each.with_index(1) { |(name, called_methods), i|
+          called_methods.each.with_index(1) { |called_method, j|
+            if use_interface_method_argument
+              called_method, sub_interfaces = called_method.to_with_interface(defined_interfaces: builder.interface_members)
+              sub_interfaces.map { builder.add_interface_members(_1) }
+            end
+
+            signature = called_method.method_sigunature(root_path: root_path, include_location: include_method_location, use_literal_type: use_literal_type, with_literal_type: with_literal_type)
+            if called_method[:singleton_method?]
+              builder.add_singleton_method(name, **signature) unless except_build_members.include? :singleton_methods
+            else
+              builder.add_method(name, **signature) unless except_build_members.include? :methods
+            end
+          }
+        }
+
+        [klass, builder.build]
+      }
+    end
+  end
+end end end

data/lib/rbs/dynamic/refine/basic_object_with_kernel.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RBS module Dynamic module Refine
+  module BasicObjectWithKernel
+    refine BasicObject do
+      def class(...)
+        ::Kernel.instance_method(:class).bind(self).call(...)
+      end
+    end
+  end
+end end end

data/lib/rbs/dynamic/refine/each_called_method.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RBS module Dynamic module Refine
+  module EachCalledMethod
+    refine Hash do
+      def each_called_method(&block)
+        return Enumerator.new { |y|
+          each_called_method { |it| y << it }
+        } unless block
+
+        self[:called_methods].each { |called_method|
+          block.call(called_method)
+          if Hash === called_method
+            called_method.each_called_method(&block)
+          end
+        }
+      end
+    end
+
+    refine Array do
+      using EachCalledMethod
+
+      def each_called_method(&block)
+        return Enumerator.new { |y|
+          each_called_method { |it| y << it }
+        } unless block
+        each { |called_method|
+          block.call(called_method)
+          called_method.each_called_method(&block)
+        }
+      end
+    end
+  end
+end end end

data/lib/rbs/dynamic/refine/signature_merger.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+
+require_relative "../builder/types.rb"
+
+module RBS module Dynamic module Refine
+  module SignatureMerger
+    module AsA
+      refine Object do
+        def as_a
+          [self]
+        end
+      end
+
+      refine Array do
+        def as_a
+          self
+        end
+      end
+    end
+    using AsA
+
+    using Module.new {
+      using RBS::Dynamic::Builder::Types::ToRBSType
+
+      refine Array do
+        # p [1, 2].zip([3, 4])            # => [[1, 3], [2, 4]]
+        # p [1, 2].zip([3, 4, 5, 6])      # => [[1, 3], [2, 4]]
+        # p [1, 2].zip_fill([3, 4, 5, 6]) # => [[1, 3], [2, 4], [nil, 5], [nil, 6]]
+        def zip_fill(other, val = nil)
+          if count < other.count
+            fill(val, count...other.count).zip(other)
+          else
+            zip(other)
+          end
+        end
+
+        def union_params_rbs_type
+          map { |a, b|
+            a ||= {}
+            b ||= {}
+            type = a.fetch(:type, []).as_a + b.fetch(:type, []).as_a
+            { name: (a[:name] || b[:name]), type: type.map { _1.to_rbs_type }.uniq }
+          }
+        end
+
+        def equal_type(other)
+          count == Array(other).count && zip(Array(other)).all? { |a, b| a.equal_type(b) }
+        end
+      end
+
+      refine Hash do
+        def equal_type(other)
+          rhs_type = Integer === self[:type] ? [Integer]
+                   : String  === self[:type] ? [String]
+                   : Symbol  === self[:type] ? [Symbol]
+                   : Array   ==  self[:type] ? [Array]   # except args
+                   : Hash    ==  self[:type] ? [Hash]    # except args
+                   : [self[:type], self[:args]]
+
+          lhs_type = Integer === other[:type] ? [Integer]
+                   : String  === other[:type] ? [String]
+                   : Symbol  === other[:type] ? [Symbol]
+                   : Array   ==  other[:type] ? [Array]   # except args
+                   : Hash    ==  other[:type] ? [Hash]    # except args
+                   : [other[:type], other[:args]]
+
+          rhs_type == lhs_type
+        end
+
+        def params
+          slice(:required_positionals, :optional_positionals, :rest_positionals, :required_keywords, :optional_keywords)
+        end
+
+        def params_with_types
+          params.to_h { |k, sigs| [k, sigs&.map { _1[:type].to_rbs_type }] }
+        end
+
+        def param_names_with_num
+          params.to_h { |key, val| [key, val.count] }
+        end
+
+        def return_type
+          fetch(:return_type, []).as_a.map { _1.to_rbs_type }
+        end
+
+        def param_mergeable?(other)
+          param_names_with_num == other.param_names_with_num &&
+            return_type == other.return_type
+        end
+
+        def return_type_mergeable?(other)
+          params_with_types == other.params_with_types
+        end
+
+        def merge_params!(other)
+          other.params.merge(self) { |key, other, current|
+            current.zip_fill(other, {}).union_params_rbs_type
+          }
+        end
+
+        def merge_params(other)
+          return unless param_mergeable?(other)
+          merge_params!(other)
+        end
+
+        def merge_return_type!(other)
+          merge(return_type: (return_type + other.return_type).uniq)
+        end
+
+        def merge_return_type(other)
+          return unless return_type_mergeable?(other)
+          merge_return_type!(other)
+        end
+      end
+    }
+
+    refine Object do
+      def merge_sig(*)
+        nil
+      end
+    end
+
+    refine Array do
+      def merge_sig(other)
+        (self + other).zip_sig
+      end
+    end
+
+    refine Hash do
+      def merge_sig(other)
+        return unless Hash === other
+
+        block_merged = self[:block]&.merge_sig(other[:block])
+
+        if merged = merge_return_type(other)
+          merged.merge(block: block_merged)
+        elsif merged = merge_params(other)
+          merged.merge(block: block_merged)
+        end
+      end
+
+      def merge_sig!(other)
+        return unless Hash === other
+
+        merge_params!(other).merge_return_type!(other)
+      end
+    end
+
+    refine Array do
+      def push_merge_sig(other)
+        each.with_index { |sig, i|
+          merged = sig.merge_sig(other)
+          if merged
+            self[i] = merged
+            return self
+          end
+        }
+        push(other)
+      end
+
+      def zip_sig
+        inject([]) { |result, sig|
+          result.push_merge_sig(sig)
+        }
+      end
+
+      def zip_sig!
+        drop(1).inject(first) { |result, sig|
+          result.merge_sig!(sig)
+        }
+      end
+    end
+  end
+end end end

data/lib/rbs/dynamic/refine/trace_point.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative "./basic_object_with_kernel.rb"
+
+module RBS module Dynamic module Refine
+  module TracePoint
+    using RBS::Dynamic::Refine::BasicObjectWithKernel
+
+    module ToRBSType
+      refine Symbol do
+        def to_rbs_value
+          self
+        end
+      end
+
+      refine Integer do
+        def to_rbs_value
+          self
+        end
+      end
+
+      refine String do
+        # No supported literal-string
+        # def to_rbs_value
+        #   self
+        # end
+      end
+
+      refine BasicObject do
+        def to_rbs_value
+          nil
+        end
+
+        def to_rbs_type(cache: [])
+          { type: Kernel.instance_method(:class).bind(self).call, value: to_rbs_value, args: [] }
+        end
+      end
+
+      refine Array do
+        def to_rbs_type(cache: [])
+          return { type: Array, value: nil, args: [[]] } if cache.include? __id__
+          { type: Array, value: nil, args: (empty? ? [[]] : [filter_map { _1.to_rbs_type(cache: cache + [__id__]) }.uniq]) }
+        end
+      end
+
+      refine Hash do
+        def to_rbs_type(cache: [])
+          return { type: Hash, value: nil, args: [[], []] } if cache.include? __id__
+          args = empty? ? [[], []] : [keys.filter_map { _1.to_rbs_type(cache: cache + [__id__]) }.uniq, values.map  { _1.to_rbs_type(cache: cache + [__id__]) }]
+          { type: Hash, value: nil, args: args }
+        end
+
+        def except_value
+          { type: self[:type], args: self[:args]&.map { |args| args.map { _1.except_value } } || [] }
+        end
+      end
+
+      refine Range do
+        def to_rbs_type(*)
+          return { type: Range, value: nil, args: [[self.begin.to_rbs_type, self.end.to_rbs_type]] }
+        end
+      end
+    end
+
+    refine ::TracePoint do
+      using ToRBSType
+      using Module.new {
+        refine Module do
+          def original_classname
+            if singleton_class?
+              self.superclass.name
+            else
+              self.name
+            end
+          end
+        end
+
+        refine Hash do
+          def to_arg_s
+            if self[:op] == :key
+              "#{self[:name]}: #{self[:value].inspect}"
+            else
+              "#{self[:name]} = #{self[:value].inspect}"
+            end
+          end
+        end
+      }
+
+      def receiver
+        self.self
+      end
+
+      def original_classname
+        if singleton_class?
+          if result = self.inspect[/#<Class:([^#].*)>/, 1]
+            result
+          else
+            self.ancestors.superclass
+          end
+        else
+          self.name
+        end
+      end
+
+      def block?
+        method_id.nil? || defined_class.nil?
+      end
+
+      def singleton_method?
+        defined_class&.singleton_class? || (Module === receiver)
+      end
+
+      def receiver_class
+        singleton_method? ? receiver : receiver.class
+      end
+
+      def receiver_defined_class
+        return defined_class unless singleton_method?
+        return defined_class unless (Module === receiver)
+        receiver.ancestors.find { _1.methods(false).include?(method_id) || _1.private_methods(false).include?(method_id) } || defined_class
+      end
+
+      def argument_param(name)
+        value = binding.local_variable_get(name)
+        { name: name, type: value.class, rbs_type: value.to_rbs_type, value_object_id: value.__id__ }
+      end
+
+      def arguments
+        parameters.map { |op, name|
+          if op == :opt && name.nil?
+            { op: op, type: NilClass, rbs_type: { type: NilClass } }
+          elsif op == :rest && name.nil? || name == :*
+            { op: op, type: Array, rbs_type: [].to_rbs_type }
+          elsif op == :keyrest && name.nil? || name == :**
+            { op: op, type: Hash, rbs_type: {}.to_rbs_type }
+          elsif op == :block && name.nil? || name == :&
+            { op: op, type: Proc, rbs_type: { type: Proc } }
+          elsif name.nil?
+            { op: op, type: NilClass, rbs_type: { type: NilClass } }
+          else
+            { op: op, name: name }.merge(argument_param(name))
+          end
+        }
+      end
+
+      def arguments_with_value
+        parameters.map { |op, name|
+          { op: op, name: name, value: binding.local_variable_get(name) }
+        }
+      end
+
+      def visibility
+        return nil if block?
+
+        if singleton_method?
+          if receiver.singleton_class.private_method_defined?(method_id)
+            :private
+          elsif receiver.singleton_class.protected_method_defined?(method_id)
+            :protected
+          else
+            :public
+          end
+        else
+          if receiver.class.private_method_defined?(method_id)
+            :private
+          elsif receiver.class.protected_method_defined?(method_id)
+            :protected
+          else
+            :public
+          end
+        end
+      end
+
+      def instance_variables_class
+        binding.eval("::Kernel.instance_method(:instance_variables).bind(self).call.to_h { [_1, ::Kernel.instance_method(:instance_variable_get).bind(self).call(_1).class] }")
+      end
+
+      def instance_variables_rbs_type
+        binding.eval("::Kernel.instance_method(:instance_variables).bind(self).call.to_h { [_1, ::Kernel.instance_method(:instance_variable_get).bind(self).call(_1)] }").to_h { [_1, _2.to_rbs_type] }
+      end
+
+      def meta
+        {
+          method_id: method_id,
+          defined_class: defined_class,
+          receiver_class: receiver_class,
+          receiver_defined_class: receiver_defined_class,
+          receiver_object_id: receiver.__id__,
+          callee_id: callee_id,
+          arguments: arguments,
+          lineno: lineno,
+          path: path,
+          visibility: visibility,
+          singleton_method?: singleton_method?,
+        }
+      end
+
+      def method_sigunature
+        if defined_class.nil?
+          "-> (#{arguments_with_value.map(&:to_arg_s).join(", ")}) {}"
+        elsif defined_class.singleton_class?
+          "#{defined_class.original_classname}.#{method_id}(#{arguments_with_value.map(&:to_arg_s).join(", ")})"
+        elsif defined_class == Object
+          "#{method_id}(#{arguments_with_value.map(&:to_arg_s).join(", ")})"
+        else
+          "#{defined_class.original_classname}##{method_id}(#{arguments_with_value.map(&:to_arg_s).join(", ")})"
+        end
+      end
+    end
+  end
+end end end

data/lib/rbs/dynamic/trace.rb

@@ -0,0 +1,30 @@
+require "rbs"
+require_relative "../dynamic.rb"
+
+$rbs_dynamic_tracer = RBS::Dynamic::Tracer::CalledMethod.new
+$rbs_dynamic_tracer.enable
+
+END {
+  $rbs_dynamic_tracer.ignore_rbs_dynamic_trace { $rbs_dynamic_tracer.disable }
+  called_methods = $rbs_dynamic_tracer.called_methods
+
+  puts "# RBS dynamic trace #{RBS::Dynamic::VERSION}"
+  puts
+
+  config = RBS::Dynamic::Config.new($rbs_dynamic_option)
+  decls = RBS::Dynamic::Converter::TraceToRBS.new(called_methods).convert(
+    root_path: config.root_path,
+    except_build_members: config.except_build_members,
+    method_defined_calssses: config.method_defined_calssses,
+    include_method_location: config.show_method_location?,
+    use_literal_type: config.use_literal_type?,
+    with_literal_type: config.with_literal_type?,
+    use_interface_method_argument: config.use_interface_method_argument?,
+    target_classname_pattern: config.target_classname_pattern,
+    ignore_classname_pattern: config.ignore_classname_pattern
+  ).values
+  stdout = StringIO.new
+  writer = RBS::Writer.new(out: stdout)
+  writer.write(decls)
+  puts stdout.string
+}