repl_type_completor 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8060250e5e4f5251ad0e55bbe62123e7990c77b390f60b20b8ededd06baadeba
-  data.tar.gz: afb502380d8e26217a95e7a8e273bf3a93242ce8f2f88acadfffe4f462a10a3d
+  metadata.gz: 96985b2dccd9d5437190f365bb6b367a4dd830cbf35c9542825b340f4d833f70
+  data.tar.gz: 53d2a4f5ef5d01b2f1626d978a385bc74d44472ff69f04fc9975b2669226a775
 SHA512:
-  metadata.gz: 99efc8d227d5a8a9003b79f3d397fb223a9c330484beee358b96d6963c03d07ac6b3d651fb0e2403d0b82dd1acaeb58834166e5a29350d0f400f3dd1071b53b7
-  data.tar.gz: 04a0c4d76215a73a41714f216a742c4dc620d042e5b34bcc6b8ccfabab006f9cf1417841be6d7a9afb0d7125388a27b9de06025ed1587193a2cf91d93a1c186c
+  metadata.gz: 61535de8984acd5d7bc82b0c93e41dac60b5e43dcf4606666f0c7df491e685c39a983cf5dfac80e368ce20e77e2211242db9e172596dfa1111f67fb9a17bdb47
+  data.tar.gz: 54c7e6900a693254db6e2d462a9b14f0cef5e514581227c2c39b1d13841fea88591f4504037b02edfe6aa1971d3ebdb9e678d735a277d98cebb6df7d372f00fb

data/lib/repl_type_completor/result.rb

@@ -64,7 +64,7 @@ module ReplTypeCompletor
       in [:gvar, name, scope]
         scope.global_variables
       in [:symbol, name]
-        Symbol.all_symbols.map { _1.inspect[1..] }
+        filter_symbol_candidates(Symbol.all_symbols, name, limit: 100)
       in [:call, name, type, self_call]
         (self_call ? type.all_methods : type.methods).map(&:to_s) - HIDDEN_METHODS
       in [:lvar_or_method, name, scope]
@@ -116,6 +116,25 @@ module ReplTypeCompletor
 
     private
 
+    def filter_symbol_candidates(symbols, prefix, limit:)
+      sym_prefix = ":#{prefix}"
+      candidates = symbols.filter_map do |s|
+        next unless s.start_with?(prefix) # Fast and inaccurate check before calling inspect
+
+        inspect = s.inspect
+        inspect[1..] if inspect.start_with?(sym_prefix) # Reject `:"a b"` when completing `:a`
+      rescue EncodingError
+        # ignore
+      end
+
+      if candidates.size > limit
+        # min(n) + max(n) is faster than sort and slice
+        candidates.min(limit - limit / 2) + candidates.max(limit / 2).reverse
+      else
+        candidates.sort
+      end
+    end
+
     def method_doc(type, name)
       type = type.types.find { _1.all_methods.include? name.to_sym }
       case type

data/lib/repl_type_completor/type_analyzer.rb

@@ -229,6 +229,11 @@ module ReplTypeCompletor
     alias evaluate_class_variable_read_node evaluate_reference_read
     alias evaluate_instance_variable_read_node evaluate_reference_read
 
+    def evaluate_it_local_variable_read_node(_node, scope)
+      # `it` is not a normal local variable. It can be overridden like `tap{p it; it=1}`.
+      # Use the name `_1` instead of `it` to avoid conflict.
+      scope['_1'] || Types::NIL
+    end
 
     def evaluate_call_node(node, scope)
       receiver_type = node.receiver ? evaluate(node.receiver, scope) : scope.self_type
@@ -262,6 +267,8 @@ module ReplTypeCompletor
                 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
               end
               result = node.block.body ? evaluate(node.block.body, block_scope) : Types::NIL
               block_scope.merge_jumps
@@ -342,14 +349,14 @@ module ReplTypeCompletor
         Types::UnionType[left, right]
       else
         right = evaluate node.value, scope
-        method_call left, node.operator, [right], nil, nil, scope, name_match: false
+        method_call left, node.binary_operator, [right], nil, nil, scope, name_match: false
       end
     end
 
     def evaluate_variable_operator_write(node, scope)
       left = scope[node.name.to_s] || Types::OBJECT
       right = evaluate node.value, scope
-      scope[node.name.to_s] = method_call left, node.operator, [right], nil, nil, scope, name_match: false
+      scope[node.name.to_s] = method_call left, node.binary_operator, [right], nil, nil, scope, name_match: false
     end
     alias evaluate_global_variable_operator_write_node evaluate_variable_operator_write
     alias evaluate_local_variable_operator_write_node evaluate_variable_operator_write
@@ -378,7 +385,7 @@ module ReplTypeCompletor
     def evaluate_constant_operator_write_node(node, scope)
       left = scope[node.name.to_s] || Types::OBJECT
       right = evaluate node.value, scope
-      scope[node.name.to_s] = method_call left, node.operator, [right], nil, nil, scope, name_match: false
+      scope[node.name.to_s] = method_call left, node.binary_operator, [right], nil, nil, scope, name_match: false
     end
 
     def evaluate_constant_and_write_node(node, scope)
@@ -395,7 +402,7 @@ module ReplTypeCompletor
     def evaluate_constant_path_operator_write_node(node, scope)
       left, receiver, _parent_module, name = evaluate_constant_node_info node.target, scope
       right = evaluate node.value, scope
-      value = method_call left, node.operator, [right], nil, nil, scope, name_match: false
+      value = method_call left, node.binary_operator, [right], nil, nil, scope, name_match: false
       const_path_write receiver, name, value, scope
       value
     end
@@ -419,16 +426,20 @@ module ReplTypeCompletor
     def evaluate_constant_path_write_node(node, scope)
       receiver = evaluate node.target.parent, scope if node.target.parent
       value = evaluate node.value, scope
-      name = const_path_name(node.target)
-      const_path_write receiver, name, value, scope
+      const_path_write receiver, node.target.name.to_s, value, scope
       value
     end
 
     def evaluate_lambda_node(node, scope)
       local_table = node.locals.to_h { [_1.to_s, Types::OBJECT] }
+
+      # `it` is not added to local_table because it is not a normal local variable.
+      # We need to explicitly add it to the scope.
+      local_table['_1'] = Types::OBJECT if node.parameters.is_a?(Prism::ItParametersNode)
+
       block_scope = Scope.new scope, { **local_table, Scope::BREAK_RESULT => nil, Scope::NEXT_RESULT => nil, Scope::RETURN_RESULT => nil }
       block_scope.conditional do |s|
-        assign_parameters node.parameters.parameters, s, [], {} if node.parameters&.parameters
+        assign_parameters node.parameters.parameters, s, [], {} if node.parameters.is_a?(Prism::ParametersNode) && node.parameters.parameters
         evaluate node.body, s if node.body
       end
       block_scope.merge_jumps
@@ -467,13 +478,19 @@ module ReplTypeCompletor
       value.is_a?(Array) ? Types.array_of(*value) : value
     end
 
-    def evaluate_if_node(node, scope) = evaluate_if_unless(node, scope)
-    def evaluate_unless_node(node, scope) = evaluate_if_unless(node, scope)
-    def evaluate_if_unless(node, scope)
+    def evaluate_if_node(node, scope)
+      evaluate node.predicate, scope
+      Types::UnionType[*scope.run_branches(
+        -> { node.statements ? evaluate(node.statements, _1) : Types::NIL },
+        -> { node.subsequent ? evaluate(node.subsequent, _1) : Types::NIL }
+      )]
+    end
+
+    def evaluate_unless_node(node, scope)
       evaluate node.predicate, scope
       Types::UnionType[*scope.run_branches(
         -> { node.statements ? evaluate(node.statements, _1) : Types::NIL },
-        -> { node.consequent ? evaluate(node.consequent, _1) : Types::NIL }
+        -> { node.else_clause ? evaluate(node.else_clause, _1) : Types::NIL }
       )]
     end
 
@@ -583,10 +600,10 @@ module ReplTypeCompletor
         end
         node.statements ? evaluate(node.statements, s) : Types::NIL
       end
-      if node.consequent # begin; rescue A; rescue B; end
+      if node.subsequent # begin; rescue A; rescue B; end
         types = scope.run_branches(
           run_rescue,
-          -> { evaluate node.consequent, _1 }
+          -> { evaluate node.subsequent, _1 }
         )
         Types::UnionType[*types]
       else
@@ -701,8 +718,8 @@ module ReplTypeCompletor
       branches = node.conditions.map do |condition|
         ->(s) { evaluate_case_when_condition condition, s }
       end
-      if node.consequent
-        branches << ->(s) { evaluate node.consequent, s }
+      if node.else_clause
+        branches << ->(s) { evaluate node.else_clause, s }
       else
         branches << ->(_s) { Types::NIL }
       end
@@ -715,8 +732,8 @@ module ReplTypeCompletor
       branches = node.conditions.map do |condition|
         ->(s) { evaluate_case_in_condition target, condition, s }
       end
-      if node.consequent
-        branches << ->(s) { evaluate node.consequent, s }
+      if node.else_clause
+        branches << ->(s) { evaluate node.else_clause, s }
       end
       Types::UnionType[*scope.run_branches(*branches)]
     end
@@ -839,16 +856,6 @@ module ReplTypeCompletor
       [args_types, kwargs_types, block_sym_node, !!block_arg]
     end
 
-    def const_path_name(node)
-      if node.respond_to?(:name)
-        # ConstantPathNode#name ConstantPathTargetNode#name is added in Prism 0.28.0
-        node.name.to_s
-      else
-        # ConstantPathNode#child ConstantPathTargetNode#child is deprecated in Prism 0.28.0
-        node.child.name.to_s
-      end
-    end
-
     def const_path_write(receiver, name, value, scope)
       if receiver # receiver::A = value
         singleton_type = receiver.types.find { _1.is_a? Types::SingletonType }
@@ -875,9 +882,9 @@ module ReplTypeCompletor
     end
 
     def evaluate_constant_node_info(node, scope)
+      name = node.name.to_s
       case node
       when Prism::ConstantPathNode
-        name = const_path_name(node)
         if node.parent
           receiver = evaluate node.parent, scope
           if receiver.is_a? Types::SingletonType
@@ -893,7 +900,6 @@ module ReplTypeCompletor
           type = Types::NIL
         end
       when Prism::ConstantReadNode
-        name = node.name.to_s
         type = scope[name]
       end
       @dig_targets.resolve type, scope if @dig_targets.target? node
@@ -1048,8 +1054,7 @@ module ReplTypeCompletor
         scope[node.name.to_s] = value
       when Prism::ConstantPathTargetNode
         receiver = evaluated_receivers&.[](node.parent) || evaluate(node.parent, scope) if node.parent
-        name = const_path_name(node)
-        const_path_write receiver, name, value, scope
+        const_path_write receiver, node.name.to_s, value, scope
       end
     end
 
@@ -1140,7 +1145,7 @@ module ReplTypeCompletor
         receiver_vars = receiver.is_a?(Types::InstanceType) ? receiver.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
+        if block && method.block && method.block.type.respond_to?(:required_positionals)
           params_type = method.block.type.required_positionals.map do |func_param|
             Types.from_rbs_type func_param.type, receiver, vars
           end

data/lib/repl_type_completor/types.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'rbs'
+require 'rubygems'
+require 'rbs/cli'
 require_relative 'methods'
 
 module ReplTypeCompletor
@@ -22,11 +25,28 @@ module ReplTypeCompletor
 
     def self.load_rbs_builder
       @load_started = true
-      require 'rbs'
-      require 'rbs/cli'
       loader = RBS::CLI::LibraryOptions.new.loader
-      loader.add path: Pathname('sig')
-      @rbs_builder = RBS::DefinitionBuilder.new env: RBS::Environment.from_loader(loader).resolve_type_names
+      sig_path = Pathname('sig')
+      loader.add path: sig_path
+      expanded_sig_path = sig_path.expand_path.to_s
+
+      unless File.exist?('rbs_collection.yaml')
+        # Load rbs signature from gems. This is a fallback when rbs_collection.yaml is not available.
+        Gem.loaded_specs.values.each do |spec|
+          gem_sig_path = File.expand_path("#{spec.gem_dir}/sig")
+          loader.add(library: spec.name, version: spec.version) if Dir.exist?(gem_sig_path) && expanded_sig_path != gem_sig_path
+        end
+      end
+
+      # Hack to make this thread priority lower, not to block the main thread.
+      thread_pass_counter = 0
+      tracepoint = TracePoint.new(:call) do
+        Thread.pass if ((thread_pass_counter += 1) % 10).zero?
+      end
+      tracepoint.enable do
+        env = RBS::Environment.from_loader(loader)
+        @rbs_builder = RBS::DefinitionBuilder.new env: env.resolve_type_names
+      end
     rescue LoadError, StandardError => e
       @rbs_load_error = e
       nil
@@ -83,7 +103,9 @@ module ReplTypeCompletor
       methods_with_score = receivers.flat_map do |receiver_type, klass, singleton|
         method = rbs_search_method klass, method_name, singleton
         next [] unless method
-        method.method_types.map do |method_type|
+        method.method_types.filter_map do |method_type|
+          next unless method_type.type.respond_to?(:required_positionals)
+
           score = 0
           score += 2 if !!method_type.block == has_block
           reqs = method_type.type.required_positionals
@@ -317,6 +339,8 @@ module ReplTypeCompletor
         self_type.transform do |type|
           if type.is_a?(SingletonType) && type.module_or_class.is_a?(Class)
             InstanceType.new type.module_or_class
+          elsif type.is_a?(InstanceType)
+            InstanceType.new type.klass
           else
             OBJECT
           end

data/lib/repl_type_completor/version.rb

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

data/lib/repl_type_completor.rb

@@ -101,6 +101,8 @@ module ReplTypeCompletor
         [op == '::' ? :call_or_const : :call, name, receiver_type, self_call]
       when Prism::LocalVariableReadNode, Prism::LocalVariableTargetNode
         [:lvar_or_method, target_node.name.to_s, calculate_scope.call]
+      when Prism::ItLocalVariableReadNode
+        [:lvar_or_method, 'it', calculate_scope.call]
       when Prism::ConstantPathNode, Prism::ConstantPathTargetNode
         name = target_node.name.to_s
         if target_node.parent # A::B
@@ -111,19 +113,7 @@ module ReplTypeCompletor
           [:const, name, Types::SingletonType.new(Object), scope]
         end
       when Prism::ConstantReadNode, Prism::ConstantTargetNode
-        name = target_node.name.to_s
-        if parents.last.is_a? Prism::ConstantPathNode
-          path_node = parents.last
-          if path_node.parent # A::B
-            receiver, scope = calculate_type_scope.call(path_node.parent)
-            [:const, name, receiver, scope]
-          else # ::A
-            scope = calculate_scope.call
-            [:const, name, Types::SingletonType.new(Object), scope]
-          end
-        else
-          [:const, name, nil, calculate_scope.call]
-        end
+        [:const, target_node.name.to_s, nil, calculate_scope.call]
       when Prism::GlobalVariableReadNode, Prism::GlobalVariableTargetNode
         [:gvar, target_node.name.to_s, calculate_scope.call]
       when Prism::InstanceVariableReadNode, Prism::InstanceVariableTargetNode
@@ -134,8 +124,8 @@ module ReplTypeCompletor
     end
 
     def find_target(node, position)
-      # Skip because NumberedParametersNode#location gives location of whole block
-      return if node.is_a? Prism::NumberedParametersNode
+      # Skip because location of these nodes gives location of whole block
+      return if node.is_a?(Prism::NumberedParametersNode) || node.is_a?(Prism::ItParametersNode)
 
       node.compact_child_nodes.each do |n|
         match = find_target(n, position)

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: repl_type_completor
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-05 00:00:00.000000000 Z
+date: 2024-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement