repl_type_completor 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f756448c4950a3ca9ed858147ed0ffaabd995dbeaaef9b98a350bf638725d8bd
-  data.tar.gz: 6a4b03f7b38a79ae78144eded5c029f153b007106d19fa0dfa13dfd9f538788c
+  metadata.gz: 45c80e0c90081af7992d51765854f270adbaec795050775ae778560737db52b2
+  data.tar.gz: 9b4745ab99625ebfd3b6c1ecb526ff6e5186ef9320873b55cc4f6d88103f25ec
 SHA512:
-  metadata.gz: 71e03d4cc913be3869480af327370a42fb1029ef30e3905463e3ae5a015ad20dcf31707d5c3806acbbb29abe4c8bc82d97f3eaab3c0e76a39b51d53cf53eb25a
-  data.tar.gz: d3225cc573618824de5c9b96d4aea64d73a3427d5d3d56893189e040246896909babf5f6a44333ba5c109cdf69cb3efc66e1853a826ba901a20b0a421ae0bb3a
+  metadata.gz: c1a11765f19a07a3cf1a387448e2a57f8d0a087991a9cdae946eebdb6000552e4b7ed7a172a1d7dc65ba273def75e345b76e7adc290cb99af153017cc84df8e8
+  data.tar.gz: 682c8671b614077226d873dba34543dfae6598fb555cefa69bdce155e09de2bb4cc5cfb107d7a5b4887e50d6381eb923b2fda1d4babb5d458b506484b118b2d5

data/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)

data/lib/repl_type_completor/result.rb

@@ -139,29 +139,37 @@ module ReplTypeCompletor
       type = type.types.find { _1.all_methods.include? name.to_sym }
       case type
       when Types::SingletonType
-        "#{Types.class_name_of(type.module_or_class)}.#{name}"
+        "#{doc_class_module_name(type.module_or_class)}.#{name}"
       when Types::InstanceType
-        "#{Types.class_name_of(type.klass)}##{name}"
+        "#{doc_class_module_name(type.klass)}##{name}"
       end
     end
 
     def call_or_const_doc(type, name)
       if name =~ /\A[A-Z]/
         type = type.types.grep(Types::SingletonType).find { _1.module_or_class.const_defined?(name) }
-        type.module_or_class == Object ? name : "#{Types.class_name_of(type.module_or_class)}::#{name}" if type
+        type.module_or_class == Object ? name : "#{doc_class_module_name(type.module_or_class)}::#{name}" if type
       else
         method_doc(type, name)
       end
     end
 
+    def doc_class_module_name(module_or_class)
+      if Class === module_or_class
+        Types.class_name_of(module_or_class)
+      else
+        Methods::MODULE_NAME_METHOD.bind_call(module_or_class) || 'Module'
+      end
+    end
+
     def value_doc(type)
       return unless type
       type.types.each do |t|
         case t
         when Types::SingletonType
-          return Types.class_name_of(t.module_or_class)
+          return doc_class_module_name(t.module_or_class)
         when Types::InstanceType
-          return Types.class_name_of(t.klass)
+          return doc_class_module_name(t.klass)
         end
       end
       nil

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

@@ -9,13 +9,13 @@ module ReplTypeCompletor
   class TypeAnalyzer
     class DigTarget
       def initialize(parents, receiver, &block)
-        @dig_ids = parents.to_h { [_1.__id__, true] }
-        @target_id = receiver.__id__
+        @dig_nodes = parents.to_h { [_1, true] }.compare_by_identity
+        @target = receiver
         @block = block
       end
 
-      def dig?(node) = @dig_ids[node.__id__]
-      def target?(node) = @target_id == node.__id__
+      def dig?(node) = @dig_nodes[node]
+      def target?(node) = @target.equal?(node)
       def resolve(type, scope)
         @block.call type, scope
       end
@@ -259,6 +259,9 @@ module ReplTypeCompletor
           call_block_proc = ->(block_args, block_self_type) do
             scope.conditional do |s|
               params_table = node.block.locals.to_h { [_1.to_s, Types::NIL] }
+              if node.block.parameters.is_a?(Prism::ItParametersNode)
+                params_table['_1'] = block_args.first || Types::NIL
+              end
               table = { **params_table, Scope::BREAK_RESULT => nil, Scope::NEXT_RESULT => nil }
               block_scope = Scope.new s, table, self_type: block_self_type, trace_ivar: !block_self_type
               # TODO kwargs
@@ -266,9 +269,9 @@ module ReplTypeCompletor
               when Prism::NumberedParametersNode
                 assign_numbered_parameters node.block.parameters.maximum, block_scope, block_args, {}
               when Prism::BlockParametersNode
-                assign_parameters node.block.parameters.parameters, block_scope, block_args, {}
-              when Prism::ItParametersNode
-                scope['_1'] = block_args.first || Types::NIL
+                if node.block.parameters.parameters
+                  assign_parameters node.block.parameters.parameters, block_scope, block_args, {}
+                end
               end
               result = node.block.body ? evaluate(node.block.body, block_scope) : Types::NIL
               block_scope.merge_jumps
@@ -447,6 +450,10 @@ module ReplTypeCompletor
       Types::PROC
     end
 
+    def evaluate_shareable_constant_node(node, scope)
+      evaluate(node.write, scope)
+    end
+
     def evaluate_reference_write(node, scope)
       scope[node.name.to_s] = evaluate node.value, scope
     end
@@ -817,7 +824,7 @@ module ReplTypeCompletor
     def evaluate_call_node_arguments(call_node, scope)
       # call_node.arguments is Prism::ArgumentsNode
       arguments = call_node.arguments&.arguments&.dup || []
-      block_arg = call_node.block.expression if call_node.block.is_a?(Prism::BlockArgumentNode)
+      block_arg = call_node.block.expression if call_node.respond_to?(:block) && call_node.block.is_a?(Prism::BlockArgumentNode)
       kwargs = arguments.pop.elements if arguments.last.is_a?(Prism::KeywordHashNode)
       args_types = arguments.map do |arg|
         case arg
@@ -1093,7 +1100,6 @@ module ReplTypeCompletor
             end
           end
         end
-        evaluate node.block.expression, scope if node.block&.expression
         receiver
       when Prism::SplatNode
         evaluate_multi_write_receiver node.expression, scope, evaluated_receivers if node.expression

data/lib/repl_type_completor/types.rb

@@ -53,15 +53,32 @@ module ReplTypeCompletor
     end
 
     def self.class_name_of(klass)
-      klass = klass.superclass if klass.singleton_class?
-      Methods::MODULE_NAME_METHOD.bind_call klass
+      while true
+        name = Methods::MODULE_NAME_METHOD.bind_call klass
+        return name if name
+
+        klass = klass.superclass
+      end
+    end
+
+    if RBS::TypeName.respond_to?(:parse) # RBS >= 3.8.0
+      def self.rbs_absolute_type_name(name)
+        RBS::TypeName.parse(name).absolute!
+      end
+    else
+      def self.rbs_absolute_type_name(name)
+        # Deprecated in RBS 3.8.0
+        RBS::TypeName(name).absolute!
+      end
     end
 
     def self.rbs_search_method(klass, method_name, singleton)
+      return unless rbs_builder
+
       klass.ancestors.each do |ancestor|
-        name = class_name_of ancestor
-        next unless name && rbs_builder
-        type_name = RBS::TypeName(name).absolute!
+        next unless (name = Methods::MODULE_NAME_METHOD.bind_call(ancestor))
+
+        type_name = rbs_absolute_type_name(name)
         definition = (singleton ? rbs_builder.build_singleton(type_name) : rbs_builder.build_instance(type_name)) rescue nil
         method = definition.methods[method_name] if definition
         return method if method
@@ -160,21 +177,20 @@ 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 }]
+      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
@@ -195,25 +211,67 @@ 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
-        name = Types.class_name_of(@klass)
-        return {} unless name && Types.rbs_builder
+        return {} unless Types.rbs_builder
 
-        type_name = RBS::TypeName(name).absolute!
+        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
@@ -222,6 +280,7 @@ module ReplTypeCompletor
           "#{inspect_without_params}#{params_string}"
         end
       end
+
       def inspect_without_params
         if klass == NilClass
           'nil'
@@ -230,7 +289,7 @@ module ReplTypeCompletor
         elsif klass == FalseClass
           'false'
         else
-          klass.singleton_class? ? klass.superclass.to_s : klass.to_s
+          klass.to_s
         end
       end
     end
@@ -258,24 +317,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
 
@@ -305,7 +366,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]
@@ -345,7 +406,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
@@ -394,6 +456,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.9"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: repl_type_completor
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - tompng
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-16 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -71,7 +70,6 @@ metadata:
   homepage_uri: https://github.com/ruby/repl_type_completor
   source_code_uri: https://github.com/ruby/repl_type_completor
   documentation_uri: https://github.com/ruby/repl_type_completor
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -86,8 +84,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Type based completion for REPL.
 test_files: []