CallTargetNode and IndexTargetNode

Author: tompng

lib/repl_type_completor.rb

@@ -91,8 +91,8 @@ def analyze_code(code, binding = Object::TOPLEVEL_BINDING)
         else
           [:symbol, name] unless name.empty?
         end
-      when Prism::CallNode
-        return if target_node.opening
+      when Prism::CallNode, Prism::CallTargetNode
+        return if target_node.is_a?(Prism::CallNode) && target_node.opening
 
         name = target_node.message.to_s
         return [:lvar_or_method, name, calculate_scope.call] if target_node.receiver.nil?

lib/repl_type_completor/type_analyzer.rb

@@ -582,8 +582,8 @@ def evaluate_rescue_node(node, scope)
           case node.reference
           when Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode
             s[node.reference.name.to_s] = error_type
-          when Prism::CallNode
-            evaluate node.reference, s
+          when Prism::CallTargetNode, Prism::IndexTargetNode
+            evaluate_multi_write_receiver node.reference, s, nil
           end
         end
         node.statements ? evaluate(node.statements, s) : Types::NIL
@@ -1034,16 +1034,15 @@ def evaluate_write(node, value, scope, evaluated_receivers)
       case node
       when Prism::MultiTargetNode
         evaluate_multi_write node, value, scope, evaluated_receivers
-      when Prism::CallNode
-        evaluated_receivers&.[](node.receiver) || evaluate(node.receiver, scope) if node.receiver
+      when Prism::CallTargetNode, Prism::IndexTargetNode
+        evaluated_receivers&.[](node.receiver) || evaluate_multi_write_receiver(node, scope, nil)
       when Prism::SplatNode
         evaluate_write node.expression, Types.array_of(value), scope, evaluated_receivers if node.expression
       when Prism::LocalVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::ConstantTargetNode
         scope[node.name.to_s] = value
       when Prism::ConstantPathTargetNode
         receiver = evaluated_receivers&.[](node.parent) || evaluate(node.parent, scope) if node.parent
         const_path_write receiver, node.child.name.to_s, value, scope
-        value
       end
     end
 
@@ -1066,20 +1065,24 @@ def evaluate_multi_write_receiver(node, scope, evaluated_receivers)
       when Prism::MultiWriteNode, Prism::MultiTargetNode
         targets = [*node.lefts, *node.rest, *node.rights]
         targets.each { evaluate_multi_write_receiver _1, scope, evaluated_receivers }
-      when Prism::CallNode
-        if node.receiver
-          receiver = evaluate(node.receiver, scope)
-          evaluated_receivers[node.receiver] = receiver if evaluated_receivers
-        end
+      when Prism::CallTargetNode, Prism::CallNode
+        receiver = evaluate(node.receiver, scope)
+        evaluated_receivers[node.receiver] = receiver if evaluated_receivers
+        receiver
+      when Prism::IndexTargetNode
+        receiver = evaluate(node.receiver, scope)
+        evaluated_receivers[node.receiver] = receiver if evaluated_receivers
         if node.arguments
           node.arguments.arguments&.each do |arg|
             if arg.is_a? Prism::SplatNode
-              evaluate arg.expression, scope
+              evaluate arg.expression, scope if arg.expression
             else
               evaluate arg, scope
             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
       end

test/repl_type_completor/test_type_analyze.rb

@@ -333,8 +333,15 @@ def test_massign
       assert_call('a, ((b=1).c, d) = 1; b.', include: Integer)
       assert_call('a, b[c=1] = 1; c.', include: Integer)
       assert_call('a, b[*(c=1)] = 1; c.', include: Integer)
+      assert_call('a, b[**(c=1)] = 1; c.', include: Integer)
+      assert_call('a, b[&(c=1)] = 1; c.', include: Integer)
+      assert_call('a, b[] = 1; a.', include: Integer)
+      assert_call('def f(*); a, b[*] = 1; a.', include: Integer)
+      assert_call('def f(&); a, b[&] = 1; a.', include: Integer)
+      assert_call('def f(**); a, b[**] = 1; a.', include: Integer)
       # incomplete massign
       assert_analyze_type('a,b', :lvar_or_method, 'b')
+      assert_call('(a=1).b, a.a', include: Integer)
       assert_call('(a=1).b, a.', include: Integer)
       assert_call('a=1; *a.', include: Integer)
     end
@@ -575,6 +582,7 @@ def test_for
       assert_call('for *,(*) in [1,2,3]; 1.', include: Integer)
       assert_call('for *i in [1,2,3]; i.sample.', include: Integer)
       assert_call('for (a=1).b in [1,2,3]; a.', include: Integer)
+      assert_call('for a[b=1] in [1,2,3]; b.', include: Integer)
       assert_call('for Array::B in [1,2,3]; Array::B.', include: Integer)
       assert_call('for A in [1,2,3]; A.', include: Integer)
       assert_call('for $a in [1,2,3]; $a.', include: Integer)