repl_type_completor 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22c32aa7e27069f8002c1fe8080bb31c8470760c6c780ba8b566252389dc326d
-  data.tar.gz: 296c548b10082570baadd90d3c94323f91373a6f0edbde307d01228aac7d83e0
+  metadata.gz: e17428782dfde53e8b592d0fb16957c02ec537bee5122a624e3a99bbfc663e5a
+  data.tar.gz: ebebeec739da4ae0e46ac690f3e238cff6759a3cedebccdf9e180e28ee6c51a8
 SHA512:
-  metadata.gz: 3494ca3dfd41ac33f784e35384299a502703e503fc94732a7572cf2c4418d7754b53dfb2be49588aca33eab595dc3ed181686b4cfc32da0a36c6523aa82183c9
-  data.tar.gz: 4beada48ab3e6d67c7543cf9a3e7797792fef8548cf4a8637024d72b865dcbb50ace5fe460ff8e504dae73e308116aefa523fdcbf4f161ed534060fa9c700e59
+  metadata.gz: d2d803e3ae97d53a1b3287b564615f9f4f9790d58065ad224d9376ec4fd2407d6df66d10c20a54175ad10c57e2b9efafe10955e01306b21c0d92213b6cc5b9e9
+  data.tar.gz: 4ffb182ae4720b9e67d4abb575c09b1e07f7c00a33c1c2601bf66f763eaa4997f8a813980b9367f47ba9731f6ce318a13b277d8c80396c9e7cfe43178896198c

data/lib/repl_type_completor/methods.rb

@@ -2,8 +2,10 @@
 
 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_DEFINED_METHOD = Object.instance_method(:instance_variable_defined?)
     OBJECT_INSTANCE_VARIABLE_GET_METHOD = Object.instance_method(:instance_variable_get)
     OBJECT_CLASS_METHOD = Object.instance_method(:class)
     MODULE_NAME_METHOD = Module.instance_method(:name)

data/lib/repl_type_completor/result.rb

@@ -72,7 +72,11 @@ module ReplTypeCompletor
       else
         []
       end
-      candidates.select { _1.start_with?(name) }.map { _1[name.size..] }
+
+      candidates.filter_map do
+        _1[name.size..] if _1.start_with?(name)
+      rescue EncodingError
+      end
     rescue Exception => e
       ReplTypeCompletor.handle_exception(e)
       []

data/lib/repl_type_completor/scope.rb

@@ -284,36 +284,19 @@ module ReplTypeCompletor
     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)

data/lib/repl_type_completor/type_analyzer.rb

@@ -1179,6 +1179,12 @@ module ReplTypeCompletor
           end
         end
       end
+
+      if types.empty? && args.empty? && !kwargs && !block
+        t = Types.accessor_method_return_type(receiver, method_name)
+        types << t if t
+      end
+
       scope&.terminate if terminates && breaks.empty?
       Types::UnionType[*types, *breaks]
     end

data/lib/repl_type_completor/types.rb

@@ -105,6 +105,28 @@ module ReplTypeCompletor
       UnionType[*types]
     end
 
+    def self.accessor_method_return_type(type, method_name)
+      return unless method_name.match?(/\A[a-z_][a-z_0-9]*\z/)
+
+      ivar_name = :"@#{method_name}"
+      instances = type.types.filter_map do |t|
+        case t
+        in SingletonType
+          t.module_or_class
+        in InstanceType
+          t.instances
+        end
+      end.flatten
+      instances = instances.sample(OBJECT_TO_TYPE_SAMPLE_SIZE) if instances.size > OBJECT_TO_TYPE_SAMPLE_SIZE
+      objects = []
+      instances.each do |instance|
+        if Methods::OBJECT_INSTANCE_VARIABLE_DEFINED_METHOD.bind_call(instance, ivar_name)
+          objects << Methods::OBJECT_INSTANCE_VARIABLE_GET_METHOD.bind_call(instance, ivar_name)
+        end
+      end
+      union_type_from_objects(objects) unless objects.empty?
+    end
+
     def self.rbs_methods(type, method_name, args_types, kwargs_type, has_block)
       return [] unless rbs_builder
 
@@ -177,21 +199,21 @@ module ReplTypeCompletor
     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 }]
+      instances = objects.size <= OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
+      modules, instances = instances.partition { Module === _1 }
+      class_instances = instances.group_by { Methods::OBJECT_CLASS_METHOD.bind_call(_1) }
+      UnionType[*class_instances.map { InstanceType.new _1, nil, _2 }, *modules.uniq.map { SingletonType.new _1 }]
     end
 
     class SingletonType
@@ -212,18 +234,59 @@ module ReplTypeCompletor
     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
 
@@ -231,14 +294,18 @@ module ReplTypeCompletor
         type_name = Types.rbs_absolute_type_name(name)
         Types.rbs_builder.build_instance(type_name).methods rescue {}
       end
+
       def inspect
-        if params.empty?
+        if !@params && (@klass == Array || @klass == Hash) && @instances
+          "#{inspect_without_params}[unresolved]"
+        elsif params.empty?
           inspect_without_params
         else
           params_string = "[#{params.map { "#{_1}: #{_2.inspect}" }.join(', ')}]"
           "#{inspect_without_params}#{params_string}"
         end
       end
+
       def inspect_without_params
         if klass == NilClass
           'nil'
@@ -247,7 +314,7 @@ module ReplTypeCompletor
         elsif klass == FalseClass
           'false'
         else
-          klass.singleton_class? ? klass.superclass.to_s : klass.to_s
+          klass.to_s
         end
       end
     end
@@ -275,24 +342,26 @@ module ReplTypeCompletor
 
       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 +391,7 @@ module ReplTypeCompletor
       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]
@@ -362,7 +431,8 @@ module ReplTypeCompletor
             OBJECT
           end
         end
-      when RBS::Types::Union
+      when RBS::Types::Union, RBS::Types::Intersection
+        # Intersection is unsupported. fallback to union type
         UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars }]
       when RBS::Types::Proc
         PROC
@@ -411,6 +481,8 @@ module ReplTypeCompletor
           params = names.map.with_index { [_1, args[_2] || OBJECT] }.to_h
         end
         InstanceType.new klass, params || {}
+      else
+        OBJECT
       end
     end
 

data/lib/repl_type_completor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ReplTypeCompletor
-  VERSION = "0.1.10"
+  VERSION = "0.1.12"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: repl_type_completor
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.12
 platform: ruby
 authors:
 - tompng
 bindir: exe
 cert_chain: []
-date: 2025-01-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -84,7 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Type based completion for REPL.
 test_files: []