Update for StringNode fix and NumberedParametersNode

Author: tompng

lib/repl_type_completor.rb

@@ -68,17 +68,18 @@ def analyze_code(code, binding = Object::TOPLEVEL_BINDING)
       calculate_type_scope = ->(node) { TypeAnalyzer.calculate_target_type_scope binding, [*parents, target_node], node }
 
       case target_node
-      when Prism::StringNode, Prism::InterpolatedStringNode
+      when Prism::StringNode
+        return unless target_node.closing&.empty?
+
         call_node, args_node = parents.last(2)
         return unless call_node.is_a?(Prism::CallNode) && call_node.receiver.nil?
         return unless args_node.is_a?(Prism::ArgumentsNode) && args_node.arguments.size == 1
 
-        content = code.byteslice(target_node.opening_loc.end_offset..)
         case call_node.name
         when :require
-          [:require, content]
+          [:require, target_node.content]
         when :require_relative
-          [:require_relative, content]
+          [:require_relative, target_node.content]
         end
       when Prism::SymbolNode
         return unless !target_node.closing || target_node.empty?
@@ -127,14 +128,8 @@ def analyze_code(code, binding = Object::TOPLEVEL_BINDING)
     end
 
     def find_target(node, position)
-      case node
-      when Prism::StringNode
-        # Unclosed quoted string has empty content and empty closing
-        return [node] if node.opening && node.closing&.empty?
-      when Prism::InterpolatedStringNode
-        # Unclosed double quoted string is InterpolatedStringNode with empty parts
-        return [node] if node.parts.empty? && node.opening && node.closing&.empty?
-      end
+      # Skip because NumberedParametersNode#location gives location of whole block
+      return if node.is_a? Prism::NumberedParametersNode
 
       node.compact_child_nodes.each do |n|
         match = find_target(n, position)

lib/repl_type_completor/type_analyzer.rb

@@ -254,16 +254,15 @@ def evaluate_call_node(node, scope)
         elsif node.block.is_a? Prism::BlockNode
           call_block_proc = ->(block_args, block_self_type) do
             scope.conditional do |s|
-              numbered_parameters = node.block.locals.grep(/\A_[1-9]/).map(&:to_s)
               params_table = node.block.locals.to_h { [_1.to_s, Types::NIL] }
               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
-              if node.block.parameters&.parameters
-                # node.block.parameters is Prism::BlockParametersNode
+              case node.block.parameters
+              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, {}
-              elsif !numbered_parameters.empty?
-                assign_numbered_parameters numbered_parameters, block_scope, block_args, {}
               end
               result = node.block.body ? evaluate(node.block.body, block_scope) : Types::NIL
               block_scope.merge_jumps
@@ -946,16 +945,13 @@ def assign_parameters(node, scope, args, kwargs)
       end
     end
 
-    def assign_numbered_parameters(numbered_parameters, scope, args, _kwargs)
-      return if numbered_parameters.empty?
-      max_num = numbered_parameters.map { _1[1].to_i }.max
-      if max_num == 1
+    def assign_numbered_parameters(maximum, scope, args, _kwargs)
+      if maximum == 1
         scope['_1'] = args.first || Types::NIL
       else
-        args = sized_splat(args.first, :to_ary, max_num) if args.size == 1
-        numbered_parameters.each do |name|
-          index = name[1].to_i - 1
-          scope[name] = args[index] || Types::NIL
+        args = sized_splat(args.first, :to_ary, maximum) if args.size == 1
+        maximum.times do |index|
+          scope["_#{index + 1}"] = args[index] || Types::NIL
         end
       end
     end

test/repl_type_completor/test_repl_type_completor.rb

@@ -29,16 +29,18 @@ def assert_doc_namespace(code, namespace, binding: empty_binding)
     def test_require
       assert_completion("require '", include: 'set')
       assert_completion("require 's", include: 'et')
+      assert_completion('require "', include: 'set')
+      assert_completion('require "s', include: 'et')
       assert_completion("require_relative 'test_", filename: __FILE__, include: 'repl_type_completor')
       assert_completion("require_relative '../repl_", filename: __FILE__, include: 'type_completor/test_repl_type_completor')
       Dir.chdir File.join(__dir__, '..') do
         assert_completion("require_relative 'repl_", filename: nil, include: 'type_completor/test_repl_type_completor')
         assert_completion("require_relative 'repl_", filename: '(irb)', include: 'type_completor/test_repl_type_completor')
       end
 
-      # Incomplete double quote string is InterpolatedStringNode
-      assert_completion('require "', include: 'set')
-      assert_completion('require "s', include: 'et')
+      # Should not complete terminated string
+      assert_nil ReplTypeCompletor.analyze('require "s"', binding: empty_binding)
+      assert_nil ReplTypeCompletor.analyze('require ?s', binding: empty_binding)
     end
 
     def test_method_block_sym