Change InstanceType structure

Actual object type was represented by InstanceType.new(object.singleton_class).	This will unnecessarily	creates	many singleton classes.
Actual array type was represented by InstanceType.new(Array, Elem: ElementType). Information of singleton methods will be lost.
Instead	of using singleton_class, InstanceType will retain actual class and actual instances. Params will be expanded lazily.

Author: tompng

lib/repl_type_completor/methods.rb

@@ -2,7 +2,8 @@
 
 module ReplTypeCompletor
   module Methods
-    OBJECT_SINGLETON_CLASS_METHOD = Object.instance_method(:singleton_class)
+    OBJECT_SINGLETON_METHODS_METHOD = Object.instance_method(:singleton_methods)
+    OBJECT_PRIVATE_METHODS_METHOD = Object.instance_method(:private_methods)
     OBJECT_INSTANCE_VARIABLES_METHOD = Object.instance_method(:instance_variables)
     OBJECT_INSTANCE_VARIABLE_GET_METHOD = Object.instance_method(:instance_variable_get)
     OBJECT_CLASS_METHOD = Object.instance_method(:class)

lib/repl_type_completor/scope.rb

@@ -284,36 +284,19 @@ def table_instance_variables
     end
 
     def instance_variables
-      self_singleton_types = self_type.types.grep(Types::SingletonType)
-      singleton_classes = self_type.types.grep(Types::InstanceType).map(&:klass).select(&:singleton_class?)
-      base_self = base_scope.self_object
-      self_instance_variables = singleton_classes.flat_map do |singleton_class|
-        if singleton_class.respond_to? :attached_object
-          Methods::OBJECT_INSTANCE_VARIABLES_METHOD.bind_call(singleton_class.attached_object).map(&:to_s)
-        elsif singleton_class == Methods::OBJECT_SINGLETON_CLASS_METHOD.bind_call(base_self)
-          Methods::OBJECT_INSTANCE_VARIABLES_METHOD.bind_call(base_self).map(&:to_s)
-        else
-          []
-        end
-      end
+      modules = self_type.types.grep(Types::SingletonType).map(&:module_or_class)
+      instances = self_type.types.grep(Types::InstanceType).filter_map(&:instances).flatten(1)
+      self_objects = modules + instances
       [
-        self_singleton_types.flat_map { _1.module_or_class.instance_variables.map(&:to_s) },
-        self_instance_variables || [],
+        self_objects.flat_map { Methods::OBJECT_INSTANCE_VARIABLES_METHOD.bind_call(_1).map(&:to_s) },
         table_instance_variables
-      ].inject(:|)
+      ].inject([], :|)
     end
 
     def self_instance_variable_get(name)
-      self_objects = self_type.types.grep(Types::SingletonType).map(&:module_or_class)
-      singleton_classes = self_type.types.grep(Types::InstanceType).map(&:klass).select(&:singleton_class?)
-      base_self = base_scope.self_object
-      singleton_classes.each do |singleton_class|
-        if singleton_class.respond_to? :attached_object
-          self_objects << singleton_class.attached_object
-        elsif singleton_class == base_self.singleton_class
-          self_objects << base_self
-        end
-      end
+      modules = self_type.types.grep(Types::SingletonType).map(&:module_or_class)
+      instances = self_type.types.grep(Types::InstanceType).filter_map(&:instances).flatten(1)
+      self_objects = modules + instances
       types = self_objects.map do |object|
         value = begin
           Methods::OBJECT_INSTANCE_VARIABLE_GET_METHOD.bind_call(object, name)

lib/repl_type_completor/types.rb

@@ -177,21 +177,20 @@ def self.intersect?(a, b)
     def self.type_from_object(object)
       case object
       when Array
-        InstanceType.new Array, { Elem: union_type_from_objects(object) }
+        InstanceType.new Array, nil, [object]
       when Hash
-        InstanceType.new Hash, { K: union_type_from_objects(object.keys), V: union_type_from_objects(object.values) }
+        InstanceType.new Hash, nil, [object]
       when Module
         SingletonType.new object
       else
-        klass = Methods::OBJECT_SINGLETON_CLASS_METHOD.bind_call(object) rescue Methods::OBJECT_CLASS_METHOD.bind_call(object)
-        InstanceType.new klass
+        InstanceType.new Methods::OBJECT_CLASS_METHOD.bind_call(object), nil, [object]
       end
     end
 
     def self.union_type_from_objects(objects)
-      values = objects.size <= OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
-      klasses = values.map { Methods::OBJECT_CLASS_METHOD.bind_call(_1) }
-      UnionType[*klasses.uniq.map { InstanceType.new _1 }]
+      instanes = objects.size <= OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
+      class_instanes = instanes.group_by { Methods::OBJECT_CLASS_METHOD.bind_call(_1) }
+      UnionType[*class_instanes.map { InstanceType.new _1, nil, _2 }]
     end
 
     class SingletonType
@@ -212,25 +211,67 @@ def inspect
     end
 
     class InstanceType
-      attr_reader :klass, :params
-      def initialize(klass, params = {})
+      attr_reader :klass, :raw_params, :instances
+      def initialize(klass, params = nil, instances = nil)
         @klass = klass
-        @params = params
+        @raw_params = params if params && !params.empty?
+        @instances = instances if instances && !instances.empty?
       end
+
       def transform() = yield(self)
-      def methods() = rbs_methods.select { _2.public? }.keys | @klass.instance_methods
-      def all_methods() = rbs_methods.keys | @klass.instance_methods | @klass.private_instance_methods
+      def methods() = rbs_methods.select { _2.public? }.keys | @klass.instance_methods | singleton_methods
+      def all_methods() = rbs_methods.keys | @klass.instance_methods | @klass.private_instance_methods | singleton_methods | instances_private_methods
+
+      def singleton_methods
+        return [] unless @instances
+        @singleton_methods ||= @instances.map do |instance|
+          Methods::OBJECT_SINGLETON_METHODS_METHOD.bind_call(instance)
+        end.inject(:|)
+      end
+
+      def instances_private_methods
+        return [] unless @instances
+        @private_instances_methods ||= @instances.map do |instance|
+          Methods::OBJECT_PRIVATE_METHODS_METHOD.bind_call(instance, false)
+        end.inject(:|)
+      end
+
+      def params
+        @params ||= expand_params
+      end
+
+      def expand_params
+        params = @raw_params || {}
+        return params unless @instances
+
+        if @klass == Array
+          type = Types.union_type_from_objects(@instances.flatten(1))
+          { Elem: UnionType[*params[:Elem], *type] }
+        elsif @klass == Hash
+          key = Types.union_type_from_objects(@instances.map(&:keys).flatten(1))
+          value = Types.union_type_from_objects(@instances.map(&:values).flatten(1))
+          {
+            K: UnionType[*params[:K], key],
+            V: UnionType[*params[:V], value]
+          }
+        else
+          params
+        end
+      end
+
       def constants() = []
       def types() = [self]
       def nillable?() = (@klass == NilClass)
       def nonnillable() = self
+
       def rbs_methods
         return {} unless Types.rbs_builder
 
         name = Types.class_name_of(@klass)
         type_name = Types.rbs_absolute_type_name(name)
         Types.rbs_builder.build_instance(type_name).methods rescue {}
       end
+
       def inspect
         if params.empty?
           inspect_without_params
@@ -239,6 +280,7 @@ def inspect
           "#{inspect_without_params}#{params_string}"
         end
       end
+
       def inspect_without_params
         if klass == NilClass
           'nil'
@@ -247,7 +289,7 @@ def inspect_without_params
         elsif klass == FalseClass
           'false'
         else
-          klass.singleton_class? ? klass.superclass.to_s : klass.to_s
+          klass.to_s
         end
       end
     end
@@ -275,24 +317,26 @@ class UnionType
 
       def initialize(*types)
         @types = []
-        singletons = []
-        instances = {}
+        singleton_types = []
+        instance_types = {}
         collect = -> type do
           case type
           in UnionType
             type.types.each(&collect)
           in InstanceType
-            params = (instances[type.klass] ||= {})
-            type.params.each do |k, v|
+            params, instances = (instance_types[type.klass] ||= [{}, []])
+            type.instances&.each { instances << _1 }
+            type.raw_params&.each do |k, v|
               (params[k] ||= []) << v
             end
           in SingletonType
-            singletons << type
+            singleton_types << type
           end
         end
         types.each(&collect)
-        @types = singletons.uniq + instances.map do |klass, params|
-          InstanceType.new(klass, params.transform_values { |v| UnionType[*v] })
+        @types = singleton_types.uniq + instance_types.map do |klass, (params, instances)|
+          params = params.transform_values { |v| UnionType[*v] }
+          InstanceType.new(klass, params, instances)
         end
       end
 
@@ -322,7 +366,7 @@ def self.[](*types)
       def methods() = @types.flat_map(&:methods).uniq
       def all_methods() = @types.flat_map(&:all_methods).uniq
       def constants() = @types.flat_map(&:constants).uniq
-      def inspect() = @types.map(&:inspect).join(' | ')
+      def inspect() = @types.map(&:inspect).sort.join(' | ')
     end
 
     BOOLEAN = UnionType[TRUE, FALSE]

test/repl_type_completor/test_repl_type_completor.rb

@@ -197,6 +197,26 @@ def test_anonymous_module
       assert_doc_namespace('m.ancestors', 'Module.ancestors', binding: bind)
     end
 
+    def test_array_singleton_method
+      assert_completion('$LOAD_PATH.', include: 'resolve_feature_path')
+      assert_completion('$LOAD_PATH.itself.', include: 'resolve_feature_path')
+      assert_completion('[$LOAD_PATH].first.', include: 'resolve_feature_path')
+      assert_completion('{ x: $LOAD_PATH }.each_value { _1.', include: 'resolve_feature_path')
+    end
+
+    def test_recursive_array
+      a = Object.new
+      b = Object.new
+      def a.foobar; end
+      def b.foobaz; end
+      arr = [a, [b]]
+      arr[1] << arr
+      bind = binding
+      assert_completion('arr.sample.foo', binding: bind, include: 'bar', exclude: 'baz')
+      assert_completion('arr.sample.sample.foo', binding: bind, include: 'baz', exclude: 'bar')
+      assert_completion('arr.sample.sample.sample.foo', binding: bind, include: 'bar', exclude: 'baz')
+    end
+
     DEPRECATED_CONST = 1
     deprecate_constant :DEPRECATED_CONST
     def test_deprecated_const_without_warning

test/repl_type_completor/test_type_analyze.rb

@@ -33,16 +33,40 @@ def assert_analyze_type(code, type, token = nil, binding: empty_binding)
       assert_equal token, result_token if token
     end
 
+    ActualInstance = Struct.new(:instance) do
+      def to_s() = instance.inspect
+      undef to_a # to suppress [*obj] being splat to array
+    end
+
+    def instance(instance)
+      ActualInstance.new(instance)
+    end
+
     def assert_call(code, include: nil, exclude: nil, binding: nil)
       raise ArgumentError if include.nil? && exclude.nil?
 
       result = analyze(code.strip, binding: binding)
       type = result[2] if result[0] == :call
-      klasses = type.types.flat_map do
-        _1.klass.singleton_class? ? [_1.klass.superclass, _1.klass] : _1.klass
+      instance_types = type.types.grep(ReplTypeCompletor::Types::InstanceType)
+      singleton_types = type.types.grep(ReplTypeCompletor::Types::SingletonType)
+      instances = {}.compare_by_identity
+      singleton_types.each { instances[_1.class_or_module] = true }
+      instance_types.each do |t|
+        t.instances&.each { instances[_1] = true }
       end
-      assert ([*include] - klasses).empty?, "Expected #{klasses} to include #{include}" if include
-      assert (klasses & [*exclude]).empty?, "Expected #{klasses} not to include #{exclude}" if exclude
+      classes = instance_types.to_h { [_1.klass, true] }
+
+      match = ->(query) do
+        case query
+        in ActualInstance
+          instances.key?(query.instance)
+        in Class
+          classes.key?(query)
+        end
+      end
+
+      assert [*include].all?(&match), "Expected #{classes.keys} #{instances.keys} to include #{include}"
+      refute [*exclude].any?(&match), "Expected #{classes.keys} #{instances.keys} not to include #{exclude}" if exclude
     end
 
     def test_lvar_ivar_gvar_cvar
@@ -89,8 +113,8 @@ class (Module.new)::A
           binding
         end
       RUBY
-      assert_call('STDIN.', include: STDIN.singleton_class)
-      assert_call('$stdin.', include: $stdin.singleton_class)
+      assert_call('STDIN.', include: instance(STDIN))
+      assert_call('$stdin.', include: instance($stdin))
       assert_call('@ivar.', include: Symbol, binding: bind)
       assert_call('@@cvar.', include: String, binding: bind)
       lbind = eval('lvar = 1; binding')
@@ -127,15 +151,15 @@ def test_module_cvar_ref
 
     def test_lvar_singleton_method
       a = 1
-      b = +''
+      b = ''
       c = Object.new
       d = [a, b, c]
       binding = Kernel.binding
       assert_call('a.', include: Integer, exclude: String, binding: binding)
-      assert_call('b.', include: b.singleton_class, exclude: [Integer, Object], binding: binding)
-      assert_call('c.', include: c.singleton_class, exclude: [Integer, String], binding: binding)
+      assert_call('b.', include: instance(b), exclude: [Integer, Object], binding: binding)
+      assert_call('c.', include: instance(c), exclude: [Integer, String], binding: binding)
       assert_call('d.', include: d.class, exclude: [Integer, String, Object], binding: binding)
-      assert_call('d.sample.', include: [Integer, String, Object], exclude: [b.singleton_class, c.singleton_class], binding: binding)
+      assert_call('d.sample.', include: [Integer, instance(b), instance(c)], binding: binding)
     end
 
     def test_local_variable_assign
@@ -401,11 +425,11 @@ def test_self
       assert_call('self.', include: [Integer], binding: integer_binding)
       string = +''
       string_binding = string.instance_eval { Kernel.binding }
-      assert_call('self.', include: [string.singleton_class], binding: string_binding)
+      assert_call('self.', include: instance(string), binding: string_binding)
       object = Object.new
       object.instance_eval { @int = 1; @string = string }
       object_binding = object.instance_eval { Kernel.binding }
-      assert_call('self.', include: [object.singleton_class], binding: object_binding)
+      assert_call('self.', include: instance(object), binding: object_binding)
       assert_call('@int.', include: [Integer], binding: object_binding)
       assert_call('@string.', include: [String], binding: object_binding)
     end

test/repl_type_completor/test_types.rb

@@ -17,8 +17,8 @@ def test_type_inspect
       assert_equal 'false', false_type.inspect
       assert_equal 'String', string_type.inspect
       assert_equal 'Array', ReplTypeCompletor::Types::InstanceType.new(Array).inspect
-      assert_equal 'true | false', true_or_false.inspect
-      assert_equal 'Array[Elem: true | false]', array_type.inspect
+      assert_equal 'false | true', true_or_false.inspect
+      assert_equal 'Array[Elem: false | true]', array_type.inspect
       assert_equal 'Array', array_type.inspect_without_params
       assert_equal 'Proc', ReplTypeCompletor::Types::PROC.inspect
       assert_equal 'Array.itself', ReplTypeCompletor::Types::SingletonType.new(Array).inspect
@@ -40,9 +40,11 @@ def bo.hash; 42; end # Needed to use this object as a hash key
       bo_value_hash_type = ReplTypeCompletor::Types.type_from_object({ x: bo })
 
       assert_equal Integer, int_type.klass
-      # Use singleton_class to autocomplete singleton methods
-      assert_equal obj.singleton_class, obj_type.klass
-      assert_equal Object.instance_method(:singleton_class).bind_call(bo), bo_type.klass
+      # Type contains actual instances to autocomplete singleton methods
+      assert_equal Object, obj_type.klass
+      assert_equal [obj], obj_type.instances
+      assert_equal BasicObject, bo_type.klass
+      assert_equal [bo], bo_type.instances
       # Array and Hash are special
       assert_equal Array, arr_type.klass
       assert_equal Array, bo_arr_type.klass
@@ -96,5 +98,21 @@ def bo.foobar; end
       type = ReplTypeCompletor::Types.type_from_object bo
       assert type.all_methods.include?(:foobar)
     end
+
+    def test_params_lazily_expanded_on_recursive_type
+      deepest = [{ 1 => 2.0 }]
+      a = deepest
+      5.times { a = ['even', [:odd, a]] }
+      deepest << a
+      type = ReplTypeCompletor::Types.type_from_object a
+      assert_equal Array, type.klass
+      10.times do |i|
+        elem_type = type.params[:Elem]
+        expected = i.even? ? [Array, String] : [Array, Symbol]
+        assert_equal expected, elem_type.types.map(&:klass).sort_by(&:name)
+        type = elem_type.types.find { _1.klass == Array }
+      end
+      assert_equal 'Hash[K: Integer, V: Float]', type.params[:Elem].types.find { _1.klass == Hash }.inspect
+    end
   end
 end