repl_type_completor 0.1.15 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: caa50a983c879f278cedebb80cb2d5dc064ebb4b5640ae874cdd30ca39d38d21
-  data.tar.gz: 3fe21b818e3badd2a11a6e7195fbe9c17e0c0ea485b3ff80056b155b2c4da1ee
+  metadata.gz: 7396517907163fafe31927aecac03274cbfaeea45a76105d8e44fadccba7ea98
+  data.tar.gz: 4c7e2f53c8cc769b955183a43a6be74ff56c3edd69362a5291340544979d12bc
 SHA512:
-  metadata.gz: d0adf80cebeb80b7ddc6b962e125ad63c487d44e91752845e4b815c99893100bfcee10c8a561d43a91111a9de8e29351bf0e0e0879ec48cc0f335aeadf2b7892
-  data.tar.gz: 66a6c6380adc0c60a2365b3da9915d978726c3ca1404750a576341c9c63bb2679748457c606833320f43c45f299ef43166eb73176aa5432eb18d2d345af19391
+  metadata.gz: 21c015fd50e3c0e35d62a8d60b055e38590c28811e69921940be67c26abe3c5d2b2ba1ab5b85ac45bffedfc1bb58f1ff1d76a38d14853b0b6d7c19718d4d327f
+  data.tar.gz: 24e8a55efc092fa2906fb5d0c2258c8b0ef403e53ac55c018429555533ff2842696f0edc1b7bb1f41f0a4739a7a5a2112e897b58ac9e9a7093c7a46e6980ec01

data/lib/repl_type_completor/result.rb

@@ -46,7 +46,7 @@ module ReplTypeCompletor
       in [:require_relative, name]
         RequirePaths.require_relative_completions(name, @source_file)
       in [:call_or_const, name, type, self_call]
-        ((self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS) | type.constants
+        ((self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS).sort | type.constants.sort
       in [:const, name, type, scope]
         if type
           scope_constants = type.types.flat_map do |t|
@@ -60,9 +60,9 @@ module ReplTypeCompletor
         ivars = scope.instance_variables.sort
         name == '@' ? ivars + scope.class_variables.sort : ivars
       in [:cvar, name, scope]
-        scope.class_variables
+        scope.class_variables.sort
       in [:gvar, name, scope]
-        scope.global_variables
+        scope.global_variables.sort
       in [:symbol, name]
         filter_symbol_candidates(Symbol.all_symbols, name, limit: 100)
       in [:aref, key_type, name, receiver_type]
@@ -70,18 +70,22 @@ module ReplTypeCompletor
         keys = receiver_type.types.grep(Types::InstanceType).select do |t|
           Hash == t.klass
         end.flat_map do |t|
-          t.instances.flat_map(&:keys).grep(key_type).uniq.sort
+          t.instances.flat_map(&:keys).grep(key_type).uniq
         end
         if key_type == Symbol
           keys = Symbol.all_symbols if keys.empty? && name.size >= 1
           filter_symbol_candidates(keys, name, limit: 100)
         else
-          keys.select { _1.start_with?(name) }.sort
+          keys.sort
         end
       in [:call, name, type, self_call]
-        (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
+        methods = (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
+        # Alphabetical order, but internal methods (leading underscore) last.
+        # `_1[0] == '_'` because `start_with?('_')` raises EncodingError if the
+        # method name's encoding is incompatible with US-ASCII.
+        methods.sort_by { [_1[0] == '_' ? 1 : 0, _1] }
       in [:lvar_or_method, name, scope]
-        scope.self_type.all_methods.map(&:to_s) | scope.local_variables | RESERVED_WORDS
+        scope.local_variables.sort | scope.self_type.all_methods.map(&:to_s).sort | RESERVED_WORDS
       else
         []
       end

data/lib/repl_type_completor/type_analyzer.rb

@@ -177,15 +177,15 @@ module ReplTypeCompletor
             hash = method_call hash, :to_hash, [], nil, nil, scope
           end
           if hash.is_a?(Types::InstanceType) && hash.klass == Hash
-            keys << hash.params[:K] if hash.params[:K]
-            values << hash.params[:V] if hash.params[:V]
+            keys << hash.params[0] if hash.params[0]
+            values << hash.params[1] if hash.params[1]
           end
         end
       end
       if keys.empty? && values.empty?
-        Types::InstanceType.new Hash
+        Types::InstanceType.new(Hash)
       else
-        Types::InstanceType.new Hash, K: Types::UnionType[*keys], V: Types::UnionType[*values]
+        Types::InstanceType.new(Hash, [Types::UnionType[*keys], Types::UnionType[*values]])
       end
     end
 
@@ -706,7 +706,7 @@ module ReplTypeCompletor
       inner_scope = Scope.new scope, { Scope::BREAK_RESULT => nil }
       ary_type = method_call collection, :to_ary, [], nil, nil, nil, name_match: false
       element_types = ary_type.types.filter_map do |ary|
-        ary.params[:Elem] if ary.is_a?(Types::InstanceType) && ary.klass == Array
+        ary.params[0] if ary.is_a?(Types::InstanceType) && ary.klass == Array
       end
       element_type = Types::UnionType[*element_types]
       inner_scope.conditional do |s|
@@ -761,7 +761,7 @@ module ReplTypeCompletor
       beg_type = evaluate node.left, scope if node.left
       end_type = evaluate node.right, scope if node.right
       elem = (Types::UnionType[*[beg_type, end_type].compact]).nonnillable
-      Types::InstanceType.new Range, Elem: elem
+      Types::InstanceType.new(Range, [elem])
     end
 
     def evaluate_defined_node(node, scope)
@@ -958,7 +958,7 @@ module ReplTypeCompletor
       end
       # node.keyword_rest is Prism::KeywordRestParameterNode or Prism::ForwardingParameterNode or Prism::NoKeywordsParameterNode
       if node.keyword_rest.is_a?(Prism::KeywordRestParameterNode) && node.keyword_rest.name
-        scope[node.keyword_rest.name.to_s] = Types::InstanceType.new(Hash, K: Types::SYMBOL, V: Types::UnionType[*kwargs.values])
+        scope[node.keyword_rest.name.to_s] = Types::InstanceType.new(Hash, [Types::SYMBOL, Types::UnionType[*kwargs.values]])
       end
       if node.block&.name
         # node.block is Prism::BlockParameterNode
@@ -1143,7 +1143,7 @@ module ReplTypeCompletor
           true
         end
       end
-      array_elem = arrays.empty? ? nil : Types::UnionType[*arrays.map { _1.params[:Elem] || Types::OBJECT }]
+      array_elem = arrays.empty? ? nil : Types::UnionType[*arrays.map { _1.params[0] || Types::OBJECT }]
       non_array = non_arrays.empty? ? nil : Types::UnionType[*non_arrays]
       [array_elem, non_array]
     end
@@ -1152,7 +1152,7 @@ module ReplTypeCompletor
       methods = Types.rbs_methods receiver, method_name.to_sym, args, kwargs, !!block
       block_called = false
       type_breaks = methods.map do |method, given_params, method_params|
-        receiver_vars = receiver.is_a?(Types::InstanceType) ? receiver.params : {}
+        receiver_vars = receiver.is_a?(Types::InstanceType) || receiver.is_a?(Types::InterfaceType) ? receiver.named_params : {}
         free_vars = method.type.free_variables - receiver_vars.keys.to_set
         vars = receiver_vars.merge Types.match_free_variables(free_vars, method_params, given_params)
         if block && method.block && method.block.type.respond_to?(:required_positionals)

data/lib/repl_type_completor/types.rb

@@ -8,6 +8,7 @@ require_relative 'methods'
 module ReplTypeCompletor
   module Types
     OBJECT_TO_TYPE_SAMPLE_SIZE = 50
+    EXPANSION_NESTING_LIMIT = 3
 
     singleton_class.attr_reader :rbs_builder, :rbs_load_error
 
@@ -75,6 +76,11 @@ module ReplTypeCompletor
     def self.rbs_search_method(klass, method_name, singleton)
       return unless rbs_builder
 
+      if klass.is_a? InterfaceType
+        definition = klass.definition
+        return definition && definition.methods[method_name]
+      end
+
       klass.ancestors.each do |ancestor|
         next unless (name = Methods::MODULE_NAME_METHOD.bind_call(ancestor))
 
@@ -93,6 +99,8 @@ module ReplTypeCompletor
           [t, t.module_or_class, true]
         in InstanceType
           [t, t.klass, false]
+        in InterfaceType
+          [t, t, false]
         end
       end
       types = receivers.flat_map do |receiver_type, klass, singleton|
@@ -115,6 +123,8 @@ module ReplTypeCompletor
           t.module_or_class
         in InstanceType
           t.instances
+        in InterfaceType
+          nil
         end
       end.flatten
       instances = instances.sample(OBJECT_TO_TYPE_SAMPLE_SIZE) if instances.size > OBJECT_TO_TYPE_SAMPLE_SIZE
@@ -136,6 +146,8 @@ module ReplTypeCompletor
           [t, t.module_or_class, true]
         in InstanceType
           [t, t.klass, false]
+        in InterfaceType
+          [t, t, false]
         end
       end
       has_splat = args_types.include?(nil)
@@ -157,7 +169,7 @@ module ReplTypeCompletor
           args = args_types
           if kwargs_type&.any? && keyreqs.empty? && keyopts.empty? && keyrest.nil?
             kw_value_type = UnionType[*kwargs_type.values]
-            args += [InstanceType.new(Hash, K: SYMBOL, V: kw_value_type)]
+            args += [InstanceType.new(Hash, [SYMBOL, kw_value_type])]
           end
           if has_splat
             score += 1 if args.count(&:itself) <= reqs.size + opts.size + trailings.size
@@ -193,7 +205,14 @@ module ReplTypeCompletor
       end
 
       aa, bb = [atypes, btypes].map {|types| (types[InstanceType] || []).map(&:klass) }
-      (aa.flat_map(&:ancestors) & bb).any?
+      return true if (aa.flat_map(&:ancestors) & bb).any?
+
+      [[atypes[InterfaceType], b], [btypes[InterfaceType], a]].any? do |interfaces, other|
+        interfaces&.any? do |interface|
+          methods = interface.methods
+          !methods.empty? && other.types.any? { |t| (methods - t.methods).empty? }
+        end
+      end
     end
 
     def self.type_from_object(object)
@@ -216,6 +235,13 @@ module ReplTypeCompletor
       UnionType[*class_instances.map { InstanceType.new _1, nil, _2 }, *modules.uniq.map { SingletonType.new _1 }]
     end
 
+    def self.union_type_from_objects_list(objects_list)
+      objects = objects_list.flat_map do |objects|
+        objects.size < OBJECT_TO_TYPE_SAMPLE_SIZE ? objects : objects.sample(OBJECT_TO_TYPE_SAMPLE_SIZE)
+      end
+      union_type_from_objects(objects)
+    end
+
     class SingletonType
       attr_reader :module_or_class
       def initialize(module_or_class)
@@ -263,20 +289,29 @@ module ReplTypeCompletor
         @params ||= expand_params
       end
 
+      def named_params
+        return {} if params.empty?
+        if Types.rbs_builder
+          type_name = Types.rbs_absolute_type_name(Types.class_name_of(@klass))
+          names = Types.rbs_builder.build_instance(type_name)&.type_params rescue nil
+        end
+        names ? names.zip(params).to_h.compact : {}
+      end
+
       def expand_params
-        params = @raw_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] }
+          type = Types.union_type_from_objects_list(@instances)
+          [UnionType[*params[0], *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]
-          }
+          key = Types.union_type_from_objects_list(@instances.map(&:keys))
+          value = Types.union_type_from_objects_list(@instances.map(&:values))
+          [
+            UnionType[*params[0], key],
+            UnionType[*params[1], value]
+          ]
         else
           params
         end
@@ -301,7 +336,12 @@ module ReplTypeCompletor
         elsif params.empty?
           inspect_without_params
         else
-          params_string = "[#{params.map { "#{_1}: #{_2.inspect}" }.join(', ')}]"
+          named = named_params
+          if named.empty? && !params.empty?
+            params_string = "[#{params.map(&:inspect).join(', ')}]"
+          else
+            params_string = "[#{named.map { "#{_1}: #{_2.inspect}" }.join(', ')}]"
+          end
           "#{inspect_without_params}#{params_string}"
         end
       end
@@ -319,6 +359,38 @@ module ReplTypeCompletor
       end
     end
 
+    class InterfaceType
+      attr_reader :name, :args
+
+      def initialize(name, args = [])
+        @name = name
+        @args = args
+      end
+
+      def definition
+        return @definition if defined?(@definition)
+
+        @definition = (Types.rbs_builder&.build_interface(@name) rescue nil)
+      end
+
+      def transform() = yield(self)
+      def methods() = definition ? definition.methods.keys : []
+      def all_methods() = methods
+
+      def named_params
+        definition ? definition.type_params.zip(@args).to_h.compact : {}
+      end
+
+      def constants() = []
+      def types() = [self]
+      def nillable?() = false
+      def nonnillable() = self
+
+      def inspect
+        args.empty? ? name.name.to_s : "#{name.name}[#{args.map(&:inspect).join(', ')}]"
+      end
+    end
+
     NIL = InstanceType.new NilClass
     OBJECT = InstanceType.new Object
     TRUE = InstanceType.new TrueClass
@@ -343,24 +415,27 @@ module ReplTypeCompletor
       def initialize(*types)
         @types = []
         singleton_types = []
+        interface_types = {}
         instance_types = {}
         collect = -> type do
           case type
           in UnionType
             type.types.each(&collect)
           in InstanceType
-            params, instances = (instance_types[type.klass] ||= [{}, []])
+            params, instances = (instance_types[type.klass] ||= [[], []])
             type.instances&.each { instances << _1 }
-            type.raw_params&.each do |k, v|
-              (params[k] ||= []) << v
+            type.raw_params&.each_with_index do |v, index|
+              (params[index] ||= []) << v
             end
           in SingletonType
             singleton_types << type
+          in InterfaceType
+            interface_types[[type.name, type.args]] ||= type
           end
         end
         types.each(&collect)
-        @types = singleton_types.uniq + instance_types.map do |klass, (params, instances)|
-          params = params.transform_values { |v| UnionType[*v] }
+        @types = singleton_types.uniq + interface_types.values + instance_types.map do |klass, (params, instances)|
+          params = params.map { |v| UnionType[*v] }
           InstanceType.new(klass, params, instances)
         end
       end
@@ -398,10 +473,18 @@ module ReplTypeCompletor
 
     def self.array_of(*types)
       type = types.size >= 2 ? UnionType[*types] : types.first || OBJECT
-      InstanceType.new Array, Elem: type
+      InstanceType.new(Array, [type])
     end
 
-    def self.from_rbs_type(return_type, self_type, extra_vars = {})
+    # Alias may validly recurse through type args (`type json = Integer | Array[json]`)
+    # and can expand exponentially (`type b = a | [a]` chains), so expansion is depth limited.
+    def self.expand_alias_type(rbs_type, nesting)
+      return if nesting >= EXPANSION_NESTING_LIMIT
+
+      rbs_builder.expand_alias2 rbs_type.name, rbs_type.args rescue nil
+    end
+
+    def self.from_rbs_type(return_type, self_type, extra_vars = {}, nesting = 0)
       case return_type
       when RBS::Types::Bases::Self
         self_type
@@ -413,12 +496,13 @@ module ReplTypeCompletor
         self_type.transform do |type|
           case type
           in SingletonType
-            InstanceType.new(self_type.module_or_class.is_a?(Class) ? Class : Module)
+            InstanceType.new(type.module_or_class.is_a?(Class) ? Class : Module)
           in InstanceType
             SingletonType.new type.klass
+          in InterfaceType
+            CLASS
           end
         end
-        UnionType[*types]
       when RBS::Types::Bases::Bool
         BOOLEAN
       when RBS::Types::Bases::Instance
@@ -433,54 +517,43 @@ module ReplTypeCompletor
         end
       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 }]
+        UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars, nesting }]
       when RBS::Types::Proc
         PROC
       when RBS::Types::Tuple
-        elem = UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars }]
-        InstanceType.new Array, Elem: elem
+        elem = UnionType[*return_type.types.map { from_rbs_type _1, self_type, extra_vars, nesting }]
+        InstanceType.new(Array, [elem])
       when RBS::Types::Record
-        InstanceType.new Hash, K: SYMBOL, V: OBJECT
+        InstanceType.new(Hash, [SYMBOL, OBJECT])
       when RBS::Types::Literal
         InstanceType.new return_type.literal.class
       when RBS::Types::Variable
         if extra_vars.key? return_type.name
           extra_vars[return_type.name]
-        elsif self_type.is_a? InstanceType
-          self_type.params[return_type.name] || OBJECT
+        elsif self_type.is_a?(InstanceType) || self_type.is_a?(InterfaceType)
+          self_type.named_params[return_type.name] || OBJECT
         elsif self_type.is_a? UnionType
           types = self_type.types.filter_map do |t|
-            t.params[return_type.name] if t.is_a? InstanceType
+            t.named_params[return_type.name] if t.is_a?(InstanceType) || t.is_a?(InterfaceType)
           end
           UnionType[*types]
         else
           OBJECT
         end
       when RBS::Types::Optional
-        UnionType[from_rbs_type(return_type.type, self_type, extra_vars), NIL]
+        UnionType[from_rbs_type(return_type.type, self_type, extra_vars, nesting), NIL]
       when RBS::Types::Alias
-        case return_type.name.name
-        when :int
-          INTEGER
-        when :boolish
-          BOOLEAN
-        when :string
-          STRING
-        else
-          # TODO: ???
-          OBJECT
-        end
+        expanded = expand_alias_type(return_type, nesting)
+        expanded ? from_rbs_type(expanded, self_type, extra_vars, nesting + 1) : OBJECT
       when RBS::Types::Interface
-        # unimplemented
-        OBJECT
+        args = return_type.args.map { from_rbs_type _1, self_type, extra_vars, nesting }
+        InterfaceType.new return_type.name, args
       when RBS::Types::ClassInstance
         klass = return_type.name.to_namespace.path.reduce(Object) { _1.const_get _2 }
         if return_type.args
-          args = return_type.args.map { from_rbs_type _1, self_type, extra_vars }
-          names = rbs_builder.build_singleton(return_type.name).type_params
-          params = names.map.with_index { [_1, args[_2] || OBJECT] }.to_h
+          params = return_type.args.map { from_rbs_type _1, self_type, extra_vars, nesting }
         end
-        InstanceType.new klass, params || {}
+        InstanceType.new(klass, params || [])
       else
         OBJECT
       end
@@ -498,24 +571,24 @@ module ReplTypeCompletor
       accumulator.transform_values { UnionType[*_1] }
     end
 
-    def self._match_free_variable(vars, rbs_type, value, accumulator)
+    def self._match_free_variable(vars, rbs_type, value, accumulator, nesting = 0)
       case [rbs_type, value]
       in [RBS::Types::Variable,]
         (accumulator[rbs_type.name] ||= []) << value if vars.include? rbs_type.name
       in [RBS::Types::ClassInstance, InstanceType]
         names = rbs_builder.build_singleton(rbs_type.name).type_params
         names.zip(rbs_type.args).each do |name, arg|
-          v = value.params[name]
-          _match_free_variable vars, arg, v, accumulator if v
+          v = value.named_params[name]
+          _match_free_variable vars, arg, v, accumulator, nesting if v
         end
       in [RBS::Types::Tuple, InstanceType] if value.klass == Array
-        v = value.params[:Elem]
+        v = value.params[0]
         rbs_type.types.each do |t|
-          _match_free_variable vars, t, v, accumulator
+          _match_free_variable vars, t, v, accumulator, nesting
         end
       in [RBS::Types::Record, InstanceType] if value.klass == Hash
         # TODO
-      in [RBS::Types::Interface,]
+      in [RBS::Types::Interface,] if nesting < EXPANSION_NESTING_LIMIT
         definition = rbs_builder.build_interface rbs_type.name
         convert = {}
         definition.type_params.zip(rbs_type.args).each do |from, arg|
@@ -527,13 +600,20 @@ module ReplTypeCompletor
           return_type = method_return_type value, method_name
           method.defs.each do |method_def|
             interface_return_type = method_def.type.type.return_type
-            _match_free_variable convert, interface_return_type, return_type, ac
+            _match_free_variable convert, interface_return_type, return_type, ac, nesting + 1
           end
         end
         convert.each do |from, to|
           values = ac[from]
           (accumulator[to] ||= []).concat values if values
         end
+      in [RBS::Types::Union,]
+        rbs_type.types.each do |t|
+          _match_free_variable vars, t, value, accumulator, nesting
+        end
+      in [RBS::Types::Alias,]
+        expanded = expand_alias_type(rbs_type, nesting)
+        _match_free_variable vars, expanded, value, accumulator, nesting + 1 if expanded
       else
       end
     end

data/lib/repl_type_completor/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: repl_type_completor
 version: !ruby/object:Gem::Version
-  version: 0.1.15
+  version: 0.1.16
 platform: ruby
 authors:
 - tompng