[ruby/yarp] Provide target node versions

https://github.com/ruby/yarp/commit/a026564d38

test/yarp/location_test.rb

@@ -215,6 +215,12 @@ module YARP
       assert_location(ClassVariableReadNode, "@@foo")
     end
 
+    def test_ClassVariableTargetNode
+      assert_location(ClassVariableTargetNode, "@@foo, @@bar = baz", 0...5) do |node|
+        node.targets.first
+      end
+    end
+
     def test_ClassVariableWriteNode
       assert_location(ClassVariableWriteNode, "@@foo = bar")
     end
@@ -237,6 +243,12 @@ module YARP
       assert_location(ConstantPathOrWriteNode, "Parent::Child ||= bar")
     end
 
+    def test_ConstantPathTargetNode
+      assert_location(ConstantPathTargetNode, "::Foo, ::Bar = baz", 0...5) do |node|
+        node.targets.first
+      end
+    end
+
     def test_ConstantPathWriteNode
       assert_location(ConstantPathWriteNode, "Foo::Bar = baz")
       assert_location(ConstantPathWriteNode, "::Foo = bar")
@@ -260,6 +272,16 @@ module YARP
       assert_location(ConstantReadNode, "Foo::Bar", 5...8, &:child)
     end
 
+    def test_ConstantTargetNode
+      assert_location(ConstantTargetNode, "Foo, Bar = baz", 0...3) do |node|
+        node.targets.first
+      end
+    end
+
+    def test_ConstantWriteNode
+      assert_location(ConstantWriteNode, "Foo = bar")
+    end
+
     def test_DefNode
       assert_location(DefNode, "def foo; bar; end")
       assert_location(DefNode, "def foo = bar")
@@ -299,6 +321,10 @@ module YARP
       end
     end
 
+    def test_FlipFlopNode
+      assert_location(FlipFlopNode, "if foo..bar; end", 3..11, &:predicate)
+    end
+
     def test_FloatNode
       assert_location(FloatNode, "0.0")
       assert_location(FloatNode, "1.0")
@@ -344,6 +370,12 @@ module YARP
       assert_location(GlobalVariableReadNode, "$foo")
     end
 
+    def test_GlobalVariableTargetNode
+      assert_location(GlobalVariableTargetNode, "$foo, $bar = baz", 0...4) do |node|
+        node.targets.first
+      end
+    end
+
     def test_GlobalVariableWriteNode
       assert_location(GlobalVariableWriteNode, "$foo = bar")
     end
@@ -390,6 +422,12 @@ module YARP
       assert_location(InstanceVariableReadNode, "@foo")
     end
 
+    def test_InstanceVariableTargetNode
+      assert_location(InstanceVariableTargetNode, "@foo, @bar = baz", 0...4) do |node|
+        node.targets.first
+      end
+    end
+
     def test_InstanceVariableWriteNode
       assert_location(InstanceVariableWriteNode, "@foo = bar")
     end
@@ -471,6 +509,12 @@ module YARP
       assert_location(LocalVariableReadNode, "foo = 1; foo", 9...12)
     end
 
+    def test_LocalVariableTargetNode
+      assert_location(LocalVariableTargetNode, "foo, bar = baz", 0...3) do |node|
+        node.targets.first
+      end
+    end
+
     def test_LocalVariableWriteNode
       assert_location(LocalVariableWriteNode, "foo = bar")
     end
@@ -751,6 +795,12 @@ module YARP
       assert_location(YieldNode, "yield(foo)")
     end
 
+    def test_all_tested
+      expected = YARP.constants.grep(/.Node$/).sort - %i[MissingNode ProgramNode]
+      actual = LocationTest.instance_methods(false).grep(/.Node$/).map { |name| name[5..].to_sym }.sort
+      assert_equal expected, actual
+    end
+
     private
 
     def assert_location(kind, source, expected = 0...source.length)

test/yarp/snapshots/begin_rescue.txt

@@ -223,7 +223,7 @@ ProgramNode(0...578)(
          (187...193),
          [ConstantReadNode(194...203)()],
          (204...206),
-         LocalVariableWriteNode(207...209)(:ex, 0, nil, (207...209), nil),
+         LocalVariableTargetNode(207...209)(:ex, 0),
          StatementsNode(212...213)(
            [CallNode(212...213)(
               nil,
@@ -241,7 +241,7 @@ ProgramNode(0...578)(
            (214...220),
            [ConstantReadNode(221...237)(), ConstantReadNode(239...255)()],
            (256...258),
-           LocalVariableWriteNode(259...261)(:ex, 0, nil, (259...261), nil),
+           LocalVariableTargetNode(259...261)(:ex, 0),
            StatementsNode(264...265)(
              [CallNode(264...265)(
                 nil,
@@ -281,7 +281,7 @@ ProgramNode(0...578)(
          (281...287),
          [ConstantReadNode(288...297)()],
          (298...300),
-         LocalVariableWriteNode(301...303)(:ex, 0, nil, (301...303), nil),
+         LocalVariableTargetNode(301...303)(:ex, 0),
          StatementsNode(306...307)(
            [CallNode(306...307)(
               nil,
@@ -532,7 +532,7 @@ ProgramNode(0...578)(
          (489...495),
          [ConstantReadNode(496...505)(), ConstantReadNode(507...522)()],
          (523...525),
-         LocalVariableWriteNode(526...528)(:ex, 0, nil, (526...528), nil),
+         LocalVariableTargetNode(526...528)(:ex, 0),
          StatementsNode(531...532)(
            [CallNode(531...532)(
               nil,
@@ -571,7 +571,7 @@ ProgramNode(0...578)(
          (548...554),
          [ConstantReadNode(555...564)()],
          (565...567),
-         LocalVariableWriteNode(568...570)(:ex, 0, nil, (568...570), nil),
+         LocalVariableTargetNode(568...570)(:ex, 0),
          StatementsNode(573...574)(
            [CallNode(573...574)(
               nil,

test/yarp/snapshots/for.txt

@@ -3,7 +3,7 @@ ProgramNode(0...143)(
   StatementsNode(0...143)(
     [ForNode(0...20)(
        MultiWriteNode(4...5)(
-         [LocalVariableWriteNode(4...5)(:i, 0, nil, (4...5), nil)],
+         [LocalVariableTargetNode(4...5)(:i, 0)],
          nil,
          nil,
          nil,
@@ -23,7 +23,7 @@ ProgramNode(0...143)(
      ),
      ForNode(22...44)(
        MultiWriteNode(26...27)(
-         [LocalVariableWriteNode(26...27)(:i, 0, nil, (26...27), nil)],
+         [LocalVariableTargetNode(26...27)(:i, 0)],
          nil,
          nil,
          nil,
@@ -43,8 +43,8 @@ ProgramNode(0...143)(
      ),
      ForNode(46...68)(
        MultiWriteNode(50...53)(
-         [LocalVariableWriteNode(50...51)(:i, 0, nil, (50...51), nil),
+         [LocalVariableTargetNode(50...51)(:i, 0),
-          LocalVariableWriteNode(52...53)(:j, 0, nil, (52...53), nil)],
+          LocalVariableTargetNode(52...53)(:j, 0)],
          nil,
          nil,
          nil,
@@ -64,9 +64,9 @@ ProgramNode(0...143)(
      ),
      ForNode(70...94)(
        MultiWriteNode(74...79)(
-         [LocalVariableWriteNode(74...75)(:i, 0, nil, (74...75), nil),
+         [LocalVariableTargetNode(74...75)(:i, 0),
-          LocalVariableWriteNode(76...77)(:j, 0, nil, (76...77), nil),
+          LocalVariableTargetNode(76...77)(:j, 0),
-          LocalVariableWriteNode(78...79)(:k, 0, nil, (78...79), nil)],
+          LocalVariableTargetNode(78...79)(:k, 0)],
          nil,
          nil,
          nil,
@@ -86,7 +86,7 @@ ProgramNode(0...143)(
      ),
      ForNode(96...119)(
        MultiWriteNode(100...101)(
-         [LocalVariableWriteNode(100...101)(:i, 0, nil, (100...101), nil)],
+         [LocalVariableTargetNode(100...101)(:i, 0)],
          nil,
          nil,
          nil,
@@ -106,7 +106,7 @@ ProgramNode(0...143)(
      ),
      ForNode(121...143)(
        MultiWriteNode(125...126)(
-         [LocalVariableWriteNode(125...126)(:i, 0, nil, (125...126), nil)],
+         [LocalVariableTargetNode(125...126)(:i, 0)],
          nil,
          nil,
          nil,

test/yarp/snapshots/seattlerb/dasgn_icky2.txt

@@ -28,7 +28,7 @@ ProgramNode(0...76)(
                 (35...41),
                 [ConstantReadNode(42...51)()],
                 (52...54),
-                LocalVariableWriteNode(55...56)(:v, 0, nil, (55...56), nil),
+                LocalVariableTargetNode(55...56)(:v, 0),
                 StatementsNode(61...66)([BreakNode(61...66)(nil, (61...66))]),
                 nil
               ),

test/yarp/snapshots/seattlerb/masgn_anon_splat_arg.txt

@@ -9,7 +9,7 @@ ProgramNode(0...8)(
           nil,
           nil
         ),
-        LocalVariableWriteNode(3...4)(:a, 0, nil, (3...4), nil)],
+        LocalVariableTargetNode(3...4)(:a, 0)],
        (5...6),
        CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b"),
        nil,

test/yarp/snapshots/seattlerb/masgn_arg_colon_arg.txt

@@ -2,7 +2,7 @@ ProgramNode(0...11)(
   [:a],
   StatementsNode(0...11)(
     [MultiWriteNode(0...11)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
         CallNode(3...7)(
           CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
           (4...6),

test/yarp/snapshots/seattlerb/masgn_arg_ident.txt

@@ -2,7 +2,7 @@ ProgramNode(0...10)(
   [:a],
   StatementsNode(0...10)(
     [MultiWriteNode(0...10)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
         CallNode(3...6)(
           CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
           (4...5),

test/yarp/snapshots/seattlerb/masgn_arg_splat_arg.txt

@@ -2,12 +2,9 @@ ProgramNode(0...12)(
   [:a, :b, :c],
   StatementsNode(0...12)(
     [MultiWriteNode(0...12)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        SplatNode(3...5)(
+        SplatNode(3...5)((3...4), LocalVariableTargetNode(4...5)(:b, 0)),
-          (3...4),
+        LocalVariableTargetNode(7...8)(:c, 0)],
-          LocalVariableWriteNode(4...5)(:b, 0, nil, (4...5), nil)
-        ),
-        LocalVariableWriteNode(7...8)(:c, 0, nil, (7...8), nil)],
        (9...10),
        CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "d"),
        nil,

test/yarp/snapshots/seattlerb/masgn_colon2.txt

@@ -2,15 +2,11 @@ ProgramNode(0...14)(
   [:a],
   StatementsNode(0...14)(
     [MultiWriteNode(0...14)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        ConstantPathWriteNode(3...7)(
+        ConstantPathTargetNode(3...7)(
-          ConstantPathNode(3...7)(
           CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
           ConstantReadNode(6...7)(),
           (4...6)
-          ),
-          nil,
-          nil
         )],
        (8...9),
        ArrayNode(10...14)(

test/yarp/snapshots/seattlerb/masgn_colon3.txt

@@ -2,15 +2,11 @@ ProgramNode(0...15)(
   [],
   StatementsNode(0...15)(
     [MultiWriteNode(0...15)(
-       [ConstantPathWriteNode(0...3)(
+       [ConstantPathTargetNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)),
-          ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)),
+        ConstantPathTargetNode(5...8)(
           nil,
-          nil
+          ConstantReadNode(7...8)(),
-        ),
+          (5...7)
-        ConstantPathWriteNode(5...8)(
-          ConstantPathNode(5...8)(nil, ConstantReadNode(7...8)(), (5...7)),
-          nil,
-          nil
         )],
        (9...10),
        ArrayNode(11...15)(

test/yarp/snapshots/seattlerb/masgn_command_call.txt

@@ -2,8 +2,7 @@ ProgramNode(0...10)(
   [:a],
   StatementsNode(0...10)(
     [MultiWriteNode(0...10)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0), SplatNode(1...2)((1...2), nil)],
-        SplatNode(1...2)((1...2), nil)],
        (3...4),
        CallNode(5...10)(
          CallNode(5...6)(nil, nil, (5...6), nil, nil, nil, nil, 2, "b"),

test/yarp/snapshots/seattlerb/masgn_double_paren.txt

@@ -3,8 +3,8 @@ ProgramNode(2...9)(
   StatementsNode(2...9)(
     [MultiWriteNode(2...9)(
        [MultiWriteNode(2...5)(
-          [LocalVariableWriteNode(2...3)(:a, 0, nil, (2...3), nil),
+          [LocalVariableTargetNode(2...3)(:a, 0),
-           LocalVariableWriteNode(4...5)(:b, 0, nil, (4...5), nil)],
+           LocalVariableTargetNode(4...5)(:b, 0)],
           nil,
           nil,
           (1...2),

test/yarp/snapshots/seattlerb/masgn_lhs_splat.txt

@@ -2,10 +2,7 @@ ProgramNode(0...12)(
   [:a],
   StatementsNode(0...12)(
     [MultiWriteNode(0...12)(
-       [SplatNode(0...2)(
+       [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:a, 0))],
-          (0...1),
-          LocalVariableWriteNode(1...2)(:a, 0, nil, (1...2), nil)
-        )],
        (3...4),
        ArrayNode(5...12)(
          [IntegerNode(5...6)(), IntegerNode(8...9)(), IntegerNode(11...12)()],

test/yarp/snapshots/seattlerb/masgn_paren.txt

@@ -2,8 +2,8 @@ ProgramNode(1...12)(
   [:a, :b],
   StatementsNode(1...12)(
     [MultiWriteNode(1...12)(
-       [LocalVariableWriteNode(1...2)(:a, 0, nil, (1...2), nil),
+       [LocalVariableTargetNode(1...2)(:a, 0),
-        LocalVariableWriteNode(4...5)(:b, 0, nil, (4...5), nil)],
+        LocalVariableTargetNode(4...5)(:b, 0)],
        (7...8),
        CallNode(9...12)(
          CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "c"),

test/yarp/snapshots/seattlerb/masgn_splat_arg.txt

@@ -3,16 +3,13 @@ ProgramNode(0...9)(
   StatementsNode(0...9)(
     [MultiWriteNode(0...9)(
        [MultiWriteNode(0...2)(
-          [SplatNode(0...2)(
+          [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:a, 0))],
-             (0...1),
-             LocalVariableWriteNode(1...2)(:a, 0, nil, (1...2), nil)
-           )],
           nil,
           nil,
           nil,
           nil
         ),
-        LocalVariableWriteNode(4...5)(:b, 0, nil, (4...5), nil)],
+        LocalVariableTargetNode(4...5)(:b, 0)],
        (6...7),
        CallNode(8...9)(nil, nil, (8...9), nil, nil, nil, nil, 2, "c"),
        nil,

test/yarp/snapshots/seattlerb/masgn_splat_arg_arg.txt

@@ -3,17 +3,14 @@ ProgramNode(0...12)(
   StatementsNode(0...12)(
     [MultiWriteNode(0...12)(
        [MultiWriteNode(0...2)(
-          [SplatNode(0...2)(
+          [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:a, 0))],
-             (0...1),
-             LocalVariableWriteNode(1...2)(:a, 0, nil, (1...2), nil)
-           )],
           nil,
           nil,
           nil,
           nil
         ),
-        LocalVariableWriteNode(4...5)(:b, 0, nil, (4...5), nil),
+        LocalVariableTargetNode(4...5)(:b, 0),
-        LocalVariableWriteNode(7...8)(:c, 0, nil, (7...8), nil)],
+        LocalVariableTargetNode(7...8)(:c, 0)],
        (9...10),
        CallNode(11...12)(nil, nil, (11...12), nil, nil, nil, nil, 2, "d"),
        nil,

test/yarp/snapshots/seattlerb/masgn_var_star_var.txt

@@ -2,9 +2,9 @@ ProgramNode(0...11)(
   [:a, :b],
   StatementsNode(0...11)(
     [MultiWriteNode(0...11)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
         SplatNode(3...4)((3...4), nil),
-        LocalVariableWriteNode(6...7)(:b, 0, nil, (6...7), nil)],
+        LocalVariableTargetNode(6...7)(:b, 0)],
        (8...9),
        CallNode(10...11)(nil, nil, (10...11), nil, nil, nil, nil, 2, "c"),
        nil,

test/yarp/snapshots/seattlerb/mlhs_back_anonsplat.txt

@@ -2,9 +2,9 @@ ProgramNode(0...14)(
   [:a, :b, :c],
   StatementsNode(0...14)(
     [MultiWriteNode(0...14)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableWriteNode(3...4)(:b, 0, nil, (3...4), nil),
+        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableWriteNode(6...7)(:c, 0, nil, (6...7), nil),
+        LocalVariableTargetNode(6...7)(:c, 0),
         SplatNode(9...10)((9...10), nil)],
        (11...12),
        CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "f"),

test/yarp/snapshots/seattlerb/mlhs_back_splat.txt

@@ -2,13 +2,10 @@ ProgramNode(0...15)(
   [:a, :b, :c, :s],
   StatementsNode(0...15)(
     [MultiWriteNode(0...15)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableWriteNode(3...4)(:b, 0, nil, (3...4), nil),
+        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableWriteNode(6...7)(:c, 0, nil, (6...7), nil),
+        LocalVariableTargetNode(6...7)(:c, 0),
-        SplatNode(9...11)(
+        SplatNode(9...11)((9...10), LocalVariableTargetNode(10...11)(:s, 0))],
-          (9...10),
-          LocalVariableWriteNode(10...11)(:s, 0, nil, (10...11), nil)
-        )],
        (12...13),
        CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "f"),
        nil,

test/yarp/snapshots/seattlerb/mlhs_front_anonsplat.txt

@@ -9,9 +9,9 @@ ProgramNode(0...14)(
           nil,
           nil
         ),
-        LocalVariableWriteNode(3...4)(:x, 0, nil, (3...4), nil),
+        LocalVariableTargetNode(3...4)(:x, 0),
-        LocalVariableWriteNode(6...7)(:y, 0, nil, (6...7), nil),
+        LocalVariableTargetNode(6...7)(:y, 0),
-        LocalVariableWriteNode(9...10)(:z, 0, nil, (9...10), nil)],
+        LocalVariableTargetNode(9...10)(:z, 0)],
        (11...12),
        CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "f"),
        nil,

test/yarp/snapshots/seattlerb/mlhs_front_splat.txt

@@ -3,18 +3,15 @@ ProgramNode(0...15)(
   StatementsNode(0...15)(
     [MultiWriteNode(0...15)(
        [MultiWriteNode(0...2)(
-          [SplatNode(0...2)(
+          [SplatNode(0...2)((0...1), LocalVariableTargetNode(1...2)(:s, 0))],
-             (0...1),
-             LocalVariableWriteNode(1...2)(:s, 0, nil, (1...2), nil)
-           )],
           nil,
           nil,
           nil,
           nil
         ),
-        LocalVariableWriteNode(4...5)(:x, 0, nil, (4...5), nil),
+        LocalVariableTargetNode(4...5)(:x, 0),
-        LocalVariableWriteNode(7...8)(:y, 0, nil, (7...8), nil),
+        LocalVariableTargetNode(7...8)(:y, 0),
-        LocalVariableWriteNode(10...11)(:z, 0, nil, (10...11), nil)],
+        LocalVariableTargetNode(10...11)(:z, 0)],
        (12...13),
        CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "f"),
        nil,

test/yarp/snapshots/seattlerb/mlhs_mid_anonsplat.txt

@@ -2,13 +2,13 @@ ProgramNode(0...23)(
   [:a, :b, :c, :x, :y, :z],
   StatementsNode(0...23)(
     [MultiWriteNode(0...23)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableWriteNode(3...4)(:b, 0, nil, (3...4), nil),
+        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableWriteNode(6...7)(:c, 0, nil, (6...7), nil),
+        LocalVariableTargetNode(6...7)(:c, 0),
         SplatNode(9...10)((9...10), nil),
-        LocalVariableWriteNode(12...13)(:x, 0, nil, (12...13), nil),
+        LocalVariableTargetNode(12...13)(:x, 0),
-        LocalVariableWriteNode(15...16)(:y, 0, nil, (15...16), nil),
+        LocalVariableTargetNode(15...16)(:y, 0),
-        LocalVariableWriteNode(18...19)(:z, 0, nil, (18...19), nil)],
+        LocalVariableTargetNode(18...19)(:z, 0)],
        (20...21),
        CallNode(22...23)(nil, nil, (22...23), nil, nil, nil, nil, 2, "f"),
        nil,

test/yarp/snapshots/seattlerb/mlhs_mid_splat.txt

@@ -2,16 +2,13 @@ ProgramNode(0...24)(
   [:a, :b, :c, :s, :x, :y, :z],
   StatementsNode(0...24)(
     [MultiWriteNode(0...24)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableWriteNode(3...4)(:b, 0, nil, (3...4), nil),
+        LocalVariableTargetNode(3...4)(:b, 0),
-        LocalVariableWriteNode(6...7)(:c, 0, nil, (6...7), nil),
+        LocalVariableTargetNode(6...7)(:c, 0),
-        SplatNode(9...11)(
+        SplatNode(9...11)((9...10), LocalVariableTargetNode(10...11)(:s, 0)),
-          (9...10),
+        LocalVariableTargetNode(13...14)(:x, 0),
-          LocalVariableWriteNode(10...11)(:s, 0, nil, (10...11), nil)
+        LocalVariableTargetNode(16...17)(:y, 0),
-        ),
+        LocalVariableTargetNode(19...20)(:z, 0)],
-        LocalVariableWriteNode(13...14)(:x, 0, nil, (13...14), nil),
-        LocalVariableWriteNode(16...17)(:y, 0, nil, (16...17), nil),
-        LocalVariableWriteNode(19...20)(:z, 0, nil, (19...20), nil)],
        (21...22),
        CallNode(23...24)(nil, nil, (23...24), nil, nil, nil, nil, 2, "f"),
        nil,

test/yarp/snapshots/seattlerb/mlhs_rescue.txt

@@ -2,8 +2,8 @@ ProgramNode(0...18)(
   [:a, :b],
   StatementsNode(0...18)(
     [MultiWriteNode(0...18)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableWriteNode(3...4)(:b, 0, nil, (3...4), nil)],
+        LocalVariableTargetNode(3...4)(:b, 0)],
        (5...6),
        RescueModifierNode(7...18)(
          CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "f"),

test/yarp/snapshots/seattlerb/parse_line_to_ary.txt

@@ -2,8 +2,8 @@ ProgramNode(0...10)(
   [:a, :b],
   StatementsNode(0...10)(
     [MultiWriteNode(0...8)(
-       [LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil),
+       [LocalVariableTargetNode(0...1)(:a, 0),
-        LocalVariableWriteNode(3...4)(:b, 0, nil, (3...4), nil)],
+        LocalVariableTargetNode(3...4)(:b, 0)],
        (5...6),
        CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "c"),
        nil,

test/yarp/snapshots/unparser/corpus/literal/assignment.txt

@@ -3,8 +3,8 @@ ProgramNode(0...704)(
   StatementsNode(0...704)(
     [GlobalVariableWriteNode(0...6)((0...2), (3...4), IntegerNode(5...6)()),
      MultiWriteNode(8...24)(
-       [GlobalVariableWriteNode(8...10)((8...10), nil, nil),
+       [GlobalVariableTargetNode(8...10)(),
-        GlobalVariableWriteNode(12...14)((12...14), nil, nil)],
+        GlobalVariableTargetNode(12...14)()],
        (16...17),
        ArrayNode(18...24)(
          [IntegerNode(19...20)(), IntegerNode(22...23)()],
@@ -16,14 +16,14 @@ ProgramNode(0...704)(
      ),
      MultiWriteNode(27...38)(
        [MultiWriteNode(27...29)(
-          [LocalVariableWriteNode(27...28)(:a, 0, nil, (27...28), nil),
+          [LocalVariableTargetNode(27...28)(:a, 0),
            SplatNode(28...29)((28...29), nil)],
           nil,
           nil,
           (26...27),
           (29...30)
         ),
-        LocalVariableWriteNode(32...33)(:b, 0, nil, (32...33), nil)],
+        LocalVariableTargetNode(32...33)(:b, 0)],
        (35...36),
        IntegerNode(37...38)(),
        (25...26),
@@ -32,7 +32,7 @@ ProgramNode(0...704)(
      MultiWriteNode(40...48)(
        [SplatNode(40...42)(
           (40...41),
-          LocalVariableWriteNode(41...42)(:a, 0, nil, (41...42), nil)
+          LocalVariableTargetNode(41...42)(:a, 0)
         )],
        (44...45),
        ArrayNode(46...48)([], (46...47), (47...48)),
@@ -42,7 +42,7 @@ ProgramNode(0...704)(
      MultiWriteNode(50...64)(
        [SplatNode(50...54)(
           (50...51),
-          LocalVariableWriteNode(51...54)(:foo, 0, nil, (51...54), nil)
+          LocalVariableTargetNode(51...54)(:foo, 0)
         )],
        (56...57),
        ArrayNode(58...64)(
@@ -54,8 +54,8 @@ ProgramNode(0...704)(
        (54...55)
      ),
      MultiWriteNode(66...84)(
-       [ClassVariableWriteNode(66...69)((66...69), nil, nil),
+       [ClassVariableTargetNode(66...69)(),
-        ClassVariableWriteNode(71...74)((71...74), nil, nil)],
+        ClassVariableTargetNode(71...74)()],
        (76...77),
        ArrayNode(78...84)(
          [IntegerNode(79...80)(), IntegerNode(82...83)()],
@@ -66,8 +66,8 @@ ProgramNode(0...704)(
        (74...75)
      ),
      MultiWriteNode(86...102)(
-       [InstanceVariableWriteNode(86...88)((86...88), nil, nil),
+       [InstanceVariableTargetNode(86...88)(),
-        InstanceVariableWriteNode(90...92)((90...92), nil, nil)],
+        InstanceVariableTargetNode(90...92)()],
        (94...95),
        ArrayNode(96...102)(
          [IntegerNode(97...98)(), IntegerNode(100...101)()],
@@ -78,10 +78,10 @@ ProgramNode(0...704)(
        (92...93)
      ),
      MultiWriteNode(104...128)(
-       [LocalVariableWriteNode(104...105)(:a, 0, nil, (104...105), nil),
+       [LocalVariableTargetNode(104...105)(:a, 0),
         MultiWriteNode(108...113)(
-          [LocalVariableWriteNode(108...109)(:b, 0, nil, (108...109), nil),
+          [LocalVariableTargetNode(108...109)(:b, 0),
-           LocalVariableWriteNode(111...112)(:c, 0, nil, (111...112), nil)],
+           LocalVariableTargetNode(111...112)(:c, 0)],
           nil,
           nil,
           (107...108),
@@ -102,7 +102,7 @@ ProgramNode(0...704)(
        (113...114)
      ),
      MultiWriteNode(130...144)(
-       [LocalVariableWriteNode(130...131)(:a, 0, nil, (130...131), nil),
+       [LocalVariableTargetNode(130...131)(:a, 0),
         SplatNode(133...134)((133...134), nil)],
        (136...137),
        ArrayNode(138...144)(
@@ -114,10 +114,10 @@ ProgramNode(0...704)(
        (134...135)
      ),
      MultiWriteNode(146...163)(
-       [LocalVariableWriteNode(146...147)(:a, 0, nil, (146...147), nil),
+       [LocalVariableTargetNode(146...147)(:a, 0),
         SplatNode(149...153)(
           (149...150),
-          LocalVariableWriteNode(150...153)(:foo, 0, nil, (150...153), nil)
+          LocalVariableTargetNode(150...153)(:foo, 0)
         )],
        (155...156),
        ArrayNode(157...163)(
@@ -129,8 +129,8 @@ ProgramNode(0...704)(
        (153...154)
      ),
      MultiWriteNode(165...179)(
-       [LocalVariableWriteNode(165...166)(:a, 0, nil, (165...166), nil),
+       [LocalVariableTargetNode(165...166)(:a, 0),
-        LocalVariableWriteNode(168...169)(:b, 0, nil, (168...169), nil)],
+        LocalVariableTargetNode(168...169)(:b, 0)],
        (171...172),
        ArrayNode(173...179)(
          [IntegerNode(174...175)(), IntegerNode(177...178)()],
@@ -141,15 +141,15 @@ ProgramNode(0...704)(
        (169...170)
      ),
      MultiWriteNode(181...192)(
-       [LocalVariableWriteNode(181...182)(:a, 0, nil, (181...182), nil),
+       [LocalVariableTargetNode(181...182)(:a, 0),
-        LocalVariableWriteNode(184...185)(:b, 0, nil, (184...185), nil)],
+        LocalVariableTargetNode(184...185)(:b, 0)],
        (187...188),
        LocalVariableReadNode(189...192)(:foo, 0),
        (180...181),
        (185...186)
      ),
      MultiWriteNode(194...203)(
-       [LocalVariableWriteNode(194...195)(:a, 0, nil, (194...195), nil),
+       [LocalVariableTargetNode(194...195)(:a, 0),
         SplatNode(195...196)((195...196), nil)],
        (198...199),
        LocalVariableReadNode(200...203)(:foo, 0),
@@ -324,14 +324,8 @@ ProgramNode(0...704)(
        ParenthesesNode(355...367)(
          StatementsNode(357...366)(
            [MultiWriteNode(357...366)(
-              [LocalVariableWriteNode(357...358)(:b, 0, nil, (357...358), nil),
+              [LocalVariableTargetNode(357...358)(:b, 0),
-               LocalVariableWriteNode(360...361)(
+               LocalVariableTargetNode(360...361)(:c, 0)],
-                 :c,
-                 0,
-                 nil,
-                 (360...361),
-                 nil
-               )],
               (363...364),
               IntegerNode(365...366)(),
               (356...357),

test/yarp/snapshots/unparser/corpus/literal/block.txt

@@ -743,7 +743,7 @@ ProgramNode(0...737)(
              (365...371),
              [ConstantReadNode(372...381)()],
              (382...384),
-             LocalVariableWriteNode(385...386)(:e, 0, nil, (385...386), nil),
+             LocalVariableTargetNode(385...386)(:e, 0),
              nil,
              nil
            ),
@@ -786,7 +786,7 @@ ProgramNode(0...737)(
              (402...408),
              [ConstantReadNode(409...418)()],
              (419...421),
-             LocalVariableWriteNode(422...425)(:bar, 0, nil, (422...425), nil),
+             LocalVariableTargetNode(422...425)(:bar, 0),
              StatementsNode(428...431)(
                [LocalVariableReadNode(428...431)(:bar, 0)]
              ),
@@ -914,13 +914,7 @@ ProgramNode(0...737)(
                 )
               )],
              (514...516),
-             LocalVariableWriteNode(517...526)(
+             LocalVariableTargetNode(517...526)(:exception, 0),
-               :exception,
-               0,
-               nil,
-               (517...526),
-               nil
-             ),
              StatementsNode(529...532)(
                [CallNode(529...532)(
                   nil,
@@ -1151,13 +1145,7 @@ ProgramNode(0...737)(
                 )
               )],
              (658...660),
-             LocalVariableWriteNode(661...670)(
+             LocalVariableTargetNode(661...670)(:exception, 0),
-               :exception,
-               0,
-               nil,
-               (661...670),
-               nil
-             ),
              StatementsNode(673...676)(
                [CallNode(673...676)(
                   nil,

test/yarp/snapshots/unparser/corpus/literal/defined.txt

@@ -18,8 +18,8 @@ ProgramNode(0...56)(
        ParenthesesNode(38...55)(
          StatementsNode(40...54)(
            [MultiWriteNode(40...54)(
-              [LocalVariableWriteNode(40...41)(:a, 0, nil, (40...41), nil),
+              [LocalVariableTargetNode(40...41)(:a, 0),
-               LocalVariableWriteNode(43...44)(:b, 0, nil, (43...44), nil)],
+               LocalVariableTargetNode(43...44)(:b, 0)],
               (46...47),
               ArrayNode(48...54)(
                 [IntegerNode(49...50)(), IntegerNode(52...53)()],

test/yarp/snapshots/unparser/corpus/literal/for.txt

@@ -9,7 +9,7 @@ ProgramNode(0...119)(
        ArgumentsNode(4...29)(
          [ForNode(4...29)(
             MultiWriteNode(8...9)(
-              [LocalVariableWriteNode(8...9)(:a, 0, nil, (8...9), nil)],
+              [LocalVariableTargetNode(8...9)(:a, 0)],
               nil,
               nil,
               nil,
@@ -52,7 +52,7 @@ ProgramNode(0...119)(
      ),
      ForNode(31...56)(
        MultiWriteNode(35...36)(
-         [LocalVariableWriteNode(35...36)(:a, 0, nil, (35...36), nil)],
+         [LocalVariableTargetNode(35...36)(:a, 0)],
          nil,
          nil,
          nil,
@@ -69,10 +69,10 @@ ProgramNode(0...119)(
      ),
      ForNode(57...88)(
        MultiWriteNode(61...68)(
-         [LocalVariableWriteNode(62...63)(:a, 0, nil, (62...63), nil),
+         [LocalVariableTargetNode(62...63)(:a, 0),
           SplatNode(65...67)(
             (65...66),
-            LocalVariableWriteNode(66...67)(:b, 0, nil, (66...67), nil)
+            LocalVariableTargetNode(66...67)(:b, 0)
           )],
          nil,
          nil,
@@ -90,8 +90,8 @@ ProgramNode(0...119)(
      ),
      ForNode(89...119)(
        MultiWriteNode(93...99)(
-         [LocalVariableWriteNode(94...95)(:a, 0, nil, (94...95), nil),
+         [LocalVariableTargetNode(94...95)(:a, 0),
-          LocalVariableWriteNode(97...98)(:b, 0, nil, (97...98), nil)],
+          LocalVariableTargetNode(97...98)(:b, 0)],
          nil,
          nil,
          (93...94),

test/yarp/snapshots/unparser/corpus/literal/kwbegin.txt

@@ -98,7 +98,7 @@ ProgramNode(0...530)(
          (133...139),
          [ConstantReadNode(140...141)()],
          (142...144),
-         LocalVariableWriteNode(145...148)(:foo, 0, nil, (145...148), nil),
+         LocalVariableTargetNode(145...148)(:foo, 0),
          nil,
          nil
        ),
@@ -294,7 +294,7 @@ ProgramNode(0...530)(
          (351...357),
          [],
          (358...360),
-         LocalVariableWriteNode(361...364)(:bar, 0, nil, (361...364), nil),
+         LocalVariableTargetNode(361...364)(:bar, 0),
          StatementsNode(367...370)(
            [LocalVariableReadNode(367...370)(:bar, 0)]
          ),
@@ -311,7 +311,7 @@ ProgramNode(0...530)(
          (388...394),
          [ConstantReadNode(395...404)(), ConstantReadNode(406...411)()],
          (412...414),
-         LocalVariableWriteNode(415...418)(:bar, 0, nil, (415...418), nil),
+         LocalVariableTargetNode(415...418)(:bar, 0),
          StatementsNode(421...424)(
            [LocalVariableReadNode(421...424)(:bar, 0)]
          ),
@@ -332,13 +332,7 @@ ProgramNode(0...530)(
             LocalVariableReadNode(461...464)(:bar, 0)
           )],
          (465...467),
-         LocalVariableWriteNode(468...477)(
+         LocalVariableTargetNode(468...477)(:exception, 0),
-           :exception,
-           0,
-           nil,
-           (468...477),
-           nil
-         ),
          StatementsNode(480...483)(
            [CallNode(480...483)(
               nil,

test/yarp/snapshots/unparser/corpus/literal/send.txt

@@ -12,20 +12,8 @@ ProgramNode(0...999)(
             ParenthesesNode(19...31)(
               StatementsNode(21...30)(
                 [MultiWriteNode(21...30)(
-                   [LocalVariableWriteNode(21...22)(
+                   [LocalVariableTargetNode(21...22)(:a, 0),
-                      :a,
+                    LocalVariableTargetNode(24...25)(:_, 0)],
-                      0,
-                      nil,
-                      (21...22),
-                      nil
-                    ),
-                    LocalVariableWriteNode(24...25)(
-                      :_,
-                      0,
-                      nil,
-                      (24...25),
-                      nil
-                    )],
                    (27...28),
                    CallNode(29...30)(
                      nil,

test/yarp/snapshots/variables.txt

@@ -8,8 +8,8 @@ ProgramNode(0...293)(
        (13...14)
      ),
      MultiWriteNode(18...34)(
-       [ClassVariableWriteNode(18...23)((18...23), nil, nil),
+       [ClassVariableTargetNode(18...23)(),
-        ClassVariableWriteNode(25...30)((25...30), nil, nil)],
+        ClassVariableTargetNode(25...30)()],
        (31...32),
        IntegerNode(33...34)(),
        nil,
@@ -45,8 +45,8 @@ ProgramNode(0...293)(
        (89...90)
      ),
      MultiWriteNode(94...108)(
-       [GlobalVariableWriteNode(94...98)((94...98), nil, nil),
+       [GlobalVariableTargetNode(94...98)(),
-        GlobalVariableWriteNode(100...104)((100...104), nil, nil)],
+        GlobalVariableTargetNode(100...104)()],
        (105...106),
        IntegerNode(107...108)(),
        nil,
@@ -62,8 +62,8 @@ ProgramNode(0...293)(
        )
      ),
      MultiWriteNode(123...137)(
-       [InstanceVariableWriteNode(123...127)((123...127), nil, nil),
+       [InstanceVariableTargetNode(123...127)(),
-        InstanceVariableWriteNode(129...133)((129...133), nil, nil)],
+        InstanceVariableTargetNode(129...133)()],
        (134...135),
        IntegerNode(136...137)(),
        nil,
@@ -108,7 +108,7 @@ ProgramNode(0...293)(
        (177...178)
      ),
      MultiWriteNode(185...198)(
-       [LocalVariableWriteNode(185...188)(:foo, 0, nil, (185...188), nil),
+       [LocalVariableTargetNode(185...188)(:foo, 0),
         SplatNode(190...191)((190...191), nil)],
        (192...193),
        ArrayNode(194...198)(
@@ -120,7 +120,7 @@ ProgramNode(0...293)(
        nil
      ),
      MultiWriteNode(200...211)(
-       [LocalVariableWriteNode(200...203)(:foo, 0, nil, (200...203), nil),
+       [LocalVariableTargetNode(200...203)(:foo, 0),
         SplatNode(203...204)((203...204), nil)],
        (205...206),
        ArrayNode(207...211)(
@@ -132,10 +132,10 @@ ProgramNode(0...293)(
        nil
      ),
      MultiWriteNode(213...229)(
-       [LocalVariableWriteNode(213...216)(:foo, 0, nil, (213...216), nil),
+       [LocalVariableTargetNode(213...216)(:foo, 0),
         SplatNode(218...222)(
           (218...219),
-          LocalVariableWriteNode(219...222)(:bar, 0, nil, (219...222), nil)
+          LocalVariableTargetNode(219...222)(:bar, 0)
         )],
        (223...224),
        ArrayNode(225...229)(
@@ -147,10 +147,10 @@ ProgramNode(0...293)(
        nil
      ),
      MultiWriteNode(231...258)(
-       [LocalVariableWriteNode(231...234)(:foo, 0, nil, (231...234), nil),
+       [LocalVariableTargetNode(231...234)(:foo, 0),
         MultiWriteNode(237...246)(
-          [LocalVariableWriteNode(237...240)(:bar, 0, nil, (237...240), nil),
+          [LocalVariableTargetNode(237...240)(:bar, 0),
-           LocalVariableWriteNode(242...245)(:baz, 0, nil, (242...245), nil)],
+           LocalVariableTargetNode(242...245)(:baz, 0)],
           nil,
           nil,
           (236...237),

test/yarp/snapshots/whitequark/and_or_masgn.txt

@@ -6,8 +6,8 @@ ProgramNode(0...40)(
        ParenthesesNode(7...19)(
          StatementsNode(8...18)(
            [MultiWriteNode(8...18)(
-              [LocalVariableWriteNode(8...9)(:a, 0, nil, (8...9), nil),
+              [LocalVariableTargetNode(8...9)(:a, 0),
-               LocalVariableWriteNode(11...12)(:b, 0, nil, (11...12), nil)],
+               LocalVariableTargetNode(11...12)(:b, 0)],
               (13...14),
               CallNode(15...18)(
                 nil,
@@ -34,8 +34,8 @@ ProgramNode(0...40)(
        ParenthesesNode(28...40)(
          StatementsNode(29...39)(
            [MultiWriteNode(29...39)(
-              [LocalVariableWriteNode(29...30)(:a, 0, nil, (29...30), nil),
+              [LocalVariableTargetNode(29...30)(:a, 0),
-               LocalVariableWriteNode(32...33)(:b, 0, nil, (32...33), nil)],
+               LocalVariableTargetNode(32...33)(:b, 0)],
               (34...35),
               CallNode(36...39)(
                 nil,

test/yarp/snapshots/whitequark/cond_begin_masgn.txt

@@ -7,8 +7,8 @@ ProgramNode(0...25)(
          StatementsNode(4...19)(
            [CallNode(4...7)(nil, nil, (4...7), nil, nil, nil, nil, 2, "bar"),
             MultiWriteNode(9...19)(
-              [LocalVariableWriteNode(9...10)(:a, 0, nil, (9...10), nil),
+              [LocalVariableTargetNode(9...10)(:a, 0),
-               LocalVariableWriteNode(12...13)(:b, 0, nil, (12...13), nil)],
+               LocalVariableTargetNode(12...13)(:b, 0)],
               (14...15),
               CallNode(16...19)(
                 nil,

test/yarp/snapshots/whitequark/for.txt

@@ -3,7 +3,7 @@ ProgramNode(0...48)(
   StatementsNode(0...48)(
     [ForNode(0...24)(
        MultiWriteNode(4...5)(
-         [LocalVariableWriteNode(4...5)(:a, 0, nil, (4...5), nil)],
+         [LocalVariableTargetNode(4...5)(:a, 0)],
          nil,
          nil,
          nil,
@@ -30,7 +30,7 @@ ProgramNode(0...48)(
      ),
      ForNode(26...48)(
        MultiWriteNode(30...31)(
-         [LocalVariableWriteNode(30...31)(:a, 0, nil, (30...31), nil)],
+         [LocalVariableTargetNode(30...31)(:a, 0)],
          nil,
          nil,
          nil,

test/yarp/snapshots/whitequark/for_mlhs.txt

@@ -3,8 +3,8 @@ ProgramNode(0...28)(
   StatementsNode(0...28)(
     [ForNode(0...28)(
        MultiWriteNode(4...8)(
-         [LocalVariableWriteNode(4...5)(:a, 0, nil, (4...5), nil),
+         [LocalVariableTargetNode(4...5)(:a, 0),
-          LocalVariableWriteNode(7...8)(:b, 0, nil, (7...8), nil)],
+          LocalVariableTargetNode(7...8)(:b, 0)],
          nil,
          nil,
          nil,

test/yarp/snapshots/whitequark/if_masgn__24.txt

@@ -6,8 +6,8 @@ ProgramNode(0...20)(
        ParenthesesNode(3...15)(
          StatementsNode(4...14)(
            [MultiWriteNode(4...14)(
-              [LocalVariableWriteNode(4...5)(:a, 0, nil, (4...5), nil),
+              [LocalVariableTargetNode(4...5)(:a, 0),
-               LocalVariableWriteNode(7...8)(:b, 0, nil, (7...8), nil)],
+               LocalVariableTargetNode(7...8)(:b, 0)],
               (9...10),
               CallNode(11...14)(
                 nil,

test/yarp/snapshots/whitequark/masgn.txt

@@ -2,8 +2,8 @@ ProgramNode(1...56)(
   [:foo, :bar, :baz],
   StatementsNode(1...56)(
     [MultiWriteNode(1...17)(
-       [LocalVariableWriteNode(1...4)(:foo, 0, nil, (1...4), nil),
+       [LocalVariableTargetNode(1...4)(:foo, 0),
-        LocalVariableWriteNode(6...9)(:bar, 0, nil, (6...9), nil)],
+        LocalVariableTargetNode(6...9)(:bar, 0)],
        (11...12),
        ArrayNode(13...17)(
          [IntegerNode(13...14)(), IntegerNode(16...17)()],
@@ -14,8 +14,8 @@ ProgramNode(1...56)(
        (9...10)
      ),
      MultiWriteNode(19...34)(
-       [LocalVariableWriteNode(19...22)(:foo, 0, nil, (19...22), nil),
+       [LocalVariableTargetNode(19...22)(:foo, 0),
-        LocalVariableWriteNode(24...27)(:bar, 0, nil, (24...27), nil)],
+        LocalVariableTargetNode(24...27)(:bar, 0)],
        (28...29),
        ArrayNode(30...34)(
          [IntegerNode(30...31)(), IntegerNode(33...34)()],
@@ -26,9 +26,9 @@ ProgramNode(1...56)(
        nil
      ),
      MultiWriteNode(36...56)(
-       [LocalVariableWriteNode(36...39)(:foo, 0, nil, (36...39), nil),
+       [LocalVariableTargetNode(36...39)(:foo, 0),
-        LocalVariableWriteNode(41...44)(:bar, 0, nil, (41...44), nil),
+        LocalVariableTargetNode(41...44)(:bar, 0),
-        LocalVariableWriteNode(46...49)(:baz, 0, nil, (46...49), nil)],
+        LocalVariableTargetNode(46...49)(:baz, 0)],
        (50...51),
        ArrayNode(52...56)(
          [IntegerNode(52...53)(), IntegerNode(55...56)()],

test/yarp/snapshots/whitequark/masgn_attr.txt

@@ -13,7 +13,7 @@ ProgramNode(0...63)(
           0,
           "A="
         ),
-        LocalVariableWriteNode(8...11)(:foo, 0, nil, (8...11), nil)],
+        LocalVariableTargetNode(8...11)(:foo, 0)],
        (12...13),
        LocalVariableReadNode(14...17)(:foo, 0),
        nil,
@@ -61,7 +61,7 @@ ProgramNode(0...63)(
           0,
           "a="
         ),
-        LocalVariableWriteNode(54...57)(:foo, 0, nil, (54...57), nil)],
+        LocalVariableTargetNode(54...57)(:foo, 0)],
        (58...59),
        LocalVariableReadNode(60...63)(:foo, 0),
        nil,

test/yarp/snapshots/whitequark/masgn_cmd.txt

@@ -2,8 +2,8 @@ ProgramNode(0...16)(
   [:foo, :bar],
   StatementsNode(0...16)(
     [MultiWriteNode(0...16)(
-       [LocalVariableWriteNode(0...3)(:foo, 0, nil, (0...3), nil),
+       [LocalVariableTargetNode(0...3)(:foo, 0),
-        LocalVariableWriteNode(5...8)(:bar, 0, nil, (5...8), nil)],
+        LocalVariableTargetNode(5...8)(:bar, 0)],
        (9...10),
        CallNode(11...16)(
          nil,

test/yarp/snapshots/whitequark/masgn_const.txt

@@ -2,28 +2,20 @@ ProgramNode(0...34)(
   [:foo],
   StatementsNode(0...34)(
     [MultiWriteNode(0...14)(
-       [ConstantPathWriteNode(0...3)(
+       [ConstantPathTargetNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)),
-          ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)),
+        LocalVariableTargetNode(5...8)(:foo, 0)],
-          nil,
-          nil
-        ),
-        LocalVariableWriteNode(5...8)(:foo, 0, nil, (5...8), nil)],
        (9...10),
        LocalVariableReadNode(11...14)(:foo, 0),
        nil,
        nil
      ),
      MultiWriteNode(16...34)(
-       [ConstantPathWriteNode(16...23)(
+       [ConstantPathTargetNode(16...23)(
-          ConstantPathNode(16...23)(
           SelfNode(16...20)(),
           ConstantReadNode(22...23)(),
           (20...22)
         ),
-          nil,
+        LocalVariableTargetNode(25...28)(:foo, 0)],
-          nil
-        ),
-        LocalVariableWriteNode(25...28)(:foo, 0, nil, (25...28), nil)],
        (29...30),
        LocalVariableReadNode(31...34)(:foo, 0),
        nil,

test/yarp/snapshots/whitequark/masgn_nested.txt

@@ -3,7 +3,7 @@ ProgramNode(2...30)(
   StatementsNode(2...30)(
     [MultiWriteNode(2...13)(
        [MultiWriteNode(2...4)(
-          [LocalVariableWriteNode(2...3)(:b, 0, nil, (2...3), nil),
+          [LocalVariableTargetNode(2...3)(:b, 0),
            SplatNode(3...4)((3...4), nil)],
           nil,
           nil,
@@ -16,10 +16,10 @@ ProgramNode(2...30)(
        (6...7)
      ),
      MultiWriteNode(15...30)(
-       [LocalVariableWriteNode(15...16)(:a, 0, nil, (15...16), nil),
+       [LocalVariableTargetNode(15...16)(:a, 0),
         MultiWriteNode(19...24)(
-          [LocalVariableWriteNode(19...20)(:b, 0, nil, (19...20), nil),
+          [LocalVariableTargetNode(19...20)(:b, 0),
-           LocalVariableWriteNode(22...23)(:c, 0, nil, (22...23), nil)],
+           LocalVariableTargetNode(22...23)(:c, 0)],
           nil,
           nil,
           (18...19),

test/yarp/snapshots/whitequark/masgn_splat.txt

@@ -16,8 +16,8 @@ ProgramNode(0...139)(
           nil,
           nil
         ),
-        LocalVariableWriteNode(12...13)(:c, 0, nil, (12...13), nil),
+        LocalVariableTargetNode(12...13)(:c, 0),
-        LocalVariableWriteNode(15...16)(:d, 0, nil, (15...16), nil)],
+        LocalVariableTargetNode(15...16)(:d, 0)],
        (17...18),
        CallNode(19...22)(nil, nil, (19...22), nil, nil, nil, nil, 2, "bar"),
        nil,
@@ -26,7 +26,7 @@ ProgramNode(0...139)(
      MultiWriteNode(24...32)(
        [SplatNode(24...26)(
           (24...25),
-          LocalVariableWriteNode(25...26)(:b, 0, nil, (25...26), nil)
+          LocalVariableTargetNode(25...26)(:b, 0)
         )],
        (27...28),
        CallNode(29...32)(nil, nil, (29...32), nil, nil, nil, nil, 2, "bar"),
@@ -37,22 +37,22 @@ ProgramNode(0...139)(
        [MultiWriteNode(34...36)(
           [SplatNode(34...36)(
              (34...35),
-             LocalVariableWriteNode(35...36)(:b, 0, nil, (35...36), nil)
+             LocalVariableTargetNode(35...36)(:b, 0)
            )],
           nil,
           nil,
           nil,
           nil
         ),
-        LocalVariableWriteNode(38...39)(:c, 0, nil, (38...39), nil)],
+        LocalVariableTargetNode(38...39)(:c, 0)],
        (40...41),
        CallNode(42...45)(nil, nil, (42...45), nil, nil, nil, nil, 2, "bar"),
        nil,
        nil
      ),
      MultiWriteNode(47...65)(
-       [InstanceVariableWriteNode(47...51)((47...51), nil, nil),
+       [InstanceVariableTargetNode(47...51)(),
-        ClassVariableWriteNode(53...58)((53...58), nil, nil)],
+        ClassVariableTargetNode(53...58)()],
        (59...60),
        ArrayNode(61...65)(
          [SplatNode(61...65)(
@@ -76,7 +76,7 @@ ProgramNode(0...139)(
        nil
      ),
      MultiWriteNode(67...77)(
-       [LocalVariableWriteNode(67...68)(:a, 0, nil, (67...68), nil),
+       [LocalVariableTargetNode(67...68)(:a, 0),
         SplatNode(70...71)((70...71), nil)],
        (72...73),
        CallNode(74...77)(nil, nil, (74...77), nil, nil, nil, nil, 2, "bar"),
@@ -84,19 +84,19 @@ ProgramNode(0...139)(
        nil
      ),
      MultiWriteNode(79...92)(
-       [LocalVariableWriteNode(79...80)(:a, 0, nil, (79...80), nil),
+       [LocalVariableTargetNode(79...80)(:a, 0),
         SplatNode(82...83)((82...83), nil),
-        LocalVariableWriteNode(85...86)(:c, 0, nil, (85...86), nil)],
+        LocalVariableTargetNode(85...86)(:c, 0)],
        (87...88),
        CallNode(89...92)(nil, nil, (89...92), nil, nil, nil, nil, 2, "bar"),
        nil,
        nil
      ),
      MultiWriteNode(94...105)(
-       [LocalVariableWriteNode(94...95)(:a, 0, nil, (94...95), nil),
+       [LocalVariableTargetNode(94...95)(:a, 0),
         SplatNode(97...99)(
           (97...98),
-          LocalVariableWriteNode(98...99)(:b, 0, nil, (98...99), nil)
+          LocalVariableTargetNode(98...99)(:b, 0)
         )],
        (100...101),
        CallNode(102...105)(
@@ -114,12 +114,12 @@ ProgramNode(0...139)(
        nil
      ),
      MultiWriteNode(107...121)(
-       [LocalVariableWriteNode(107...108)(:a, 0, nil, (107...108), nil),
+       [LocalVariableTargetNode(107...108)(:a, 0),
         SplatNode(110...112)(
           (110...111),
-          LocalVariableWriteNode(111...112)(:b, 0, nil, (111...112), nil)
+          LocalVariableTargetNode(111...112)(:b, 0)
         ),
-        LocalVariableWriteNode(114...115)(:c, 0, nil, (114...115), nil)],
+        LocalVariableTargetNode(114...115)(:c, 0)],
        (116...117),
        CallNode(118...121)(
          nil,
@@ -136,8 +136,8 @@ ProgramNode(0...139)(
        nil
      ),
      MultiWriteNode(123...139)(
-       [LocalVariableWriteNode(123...124)(:a, 0, nil, (123...124), nil),
+       [LocalVariableTargetNode(123...124)(:a, 0),
-        LocalVariableWriteNode(126...127)(:b, 0, nil, (126...127), nil)],
+        LocalVariableTargetNode(126...127)(:b, 0)],
        (128...129),
        ArrayNode(130...139)(
          [SplatNode(130...134)(

test/yarp/snapshots/whitequark/not_masgn__24.txt

@@ -5,8 +5,8 @@ ProgramNode(0...13)(
        ParenthesesNode(1...13)(
          StatementsNode(2...12)(
            [MultiWriteNode(2...12)(
-              [LocalVariableWriteNode(2...3)(:a, 0, nil, (2...3), nil),
+              [LocalVariableTargetNode(2...3)(:a, 0),
-               LocalVariableWriteNode(5...6)(:b, 0, nil, (5...6), nil)],
+               LocalVariableTargetNode(5...6)(:b, 0)],
               (7...8),
               CallNode(9...12)(
                 nil,

test/yarp/snapshots/whitequark/resbody_list_var.txt

@@ -20,7 +20,7 @@ ProgramNode(0...39)(
             "foo"
           )],
          (24...26),
-         LocalVariableWriteNode(27...29)(:ex, 0, nil, (27...29), nil),
+         LocalVariableTargetNode(27...29)(:ex, 0),
          StatementsNode(31...34)(
            [CallNode(31...34)(
               nil,

test/yarp/snapshots/whitequark/resbody_var.txt

@@ -10,7 +10,7 @@ ProgramNode(0...73)(
          (13...19),
          [],
          (20...22),
-         InstanceVariableWriteNode(23...26)((23...26), nil, nil),
+         InstanceVariableTargetNode(23...26)(),
          StatementsNode(28...31)(
            [CallNode(28...31)(
               nil,
@@ -49,7 +49,7 @@ ProgramNode(0...73)(
          (51...57),
          [],
          (58...60),
-         LocalVariableWriteNode(61...63)(:ex, 0, nil, (61...63), nil),
+         LocalVariableTargetNode(61...63)(:ex, 0),
          StatementsNode(65...68)(
            [CallNode(65...68)(
               nil,

test/yarp/snapshots/whitequark/rescue_mod_masgn.txt

@@ -2,8 +2,8 @@ ProgramNode(0...29)(
   [:foo, :bar],
   StatementsNode(0...29)(
     [MultiWriteNode(0...29)(
-       [LocalVariableWriteNode(0...3)(:foo, 0, nil, (0...3), nil),
+       [LocalVariableTargetNode(0...3)(:foo, 0),
-        LocalVariableWriteNode(5...8)(:bar, 0, nil, (5...8), nil)],
+        LocalVariableTargetNode(5...8)(:bar, 0)],
        (9...10),
        RescueModifierNode(11...29)(
          CallNode(11...15)(nil, nil, (11...15), nil, nil, nil, nil, 2, "meth"),

yarp/config.yml

@@ -772,6 +772,12 @@ nodes:
 
           @@foo
           ^^^^^
+  - name: ClassVariableTargetNode
+    comment: |
+      Represents writing to a class variable in a context that doesn't have an explicit value.
+
+          @@foo, @@bar = baz
+          ^^^^^  ^^^^^
   - name: ClassVariableWriteNode
     child_nodes:
       - name: name_loc
@@ -883,6 +889,19 @@ nodes:
 
           Parent::Child ||= value
           ^^^^^^^^^^^^^^^^^^^^^^^
+  - name: ConstantPathTargetNode
+    child_nodes:
+      - name: parent
+        type: node?
+      - name: child
+        type: node
+      - name: delimiter_loc
+        type: location
+    comment: |
+      Represents writing to a constant path in a context that doesn't have an explicit value.
+
+          Foo::Foo, Bar::Bar = baz
+          ^^^^^^^^  ^^^^^^^^
   - name: ConstantPathWriteNode
     child_nodes:
       - name: target
@@ -909,6 +928,12 @@ nodes:
 
           Foo
           ^^^
+  - name: ConstantTargetNode
+    comment: |
+      Represents writing to a constant in a context that doesn't have an explicit value.
+
+          Foo, Bar = baz
+          ^^^  ^^^
   - name: ConstantWriteNode
     child_nodes:
       - name: name_loc
@@ -1172,6 +1197,12 @@ nodes:
 
           $foo
           ^^^^
+  - name: GlobalVariableTargetNode
+    comment: |
+      Represents writing to a global variable in a context that doesn't have an explicit value.
+
+          $foo, $bar = baz
+          ^^^^  ^^^^
   - name: GlobalVariableWriteNode
     child_nodes:
       - name: name_loc
@@ -1312,6 +1343,12 @@ nodes:
 
           @foo
           ^^^^
+  - name: InstanceVariableTargetNode
+    comment: |
+      Represents writing to an instance variable in a context that doesn't have an explicit value.
+
+          @foo, @bar = baz
+          ^^^^  ^^^^
   - name: InstanceVariableWriteNode
     child_nodes:
       - name: name_loc
@@ -1509,6 +1546,17 @@ nodes:
 
           foo
           ^^^
+  - name: LocalVariableTargetNode
+    child_nodes:
+      - name: constant_id
+        type: constant
+      - name: depth
+        type: uint32
+    comment: |
+      Represents writing to a local variable in a context that doesn't have an explicit value.
+
+          foo, bar = baz
+          ^^^  ^^^
   - name: LocalVariableWriteNode
     child_nodes:
       - name: constant_id

yarp/yarp.c

@@ -1641,10 +1641,10 @@ yp_class_variable_read_node_to_class_variable_write_node(yp_parser_t *parser, yp
             .type = YP_NODE_CLASS_VARIABLE_WRITE_NODE,
             .location = {
                 .start = read_node->base.location.start,
-                .end = value != NULL ? value->location.end : read_node->base.location.end
+                .end = value->location.end
             },
         },
-        .name_loc = YP_LOCATION_NODE_VALUE((yp_node_t *)read_node),
+        .name_loc = YP_LOCATION_NODE_VALUE((yp_node_t *) read_node),
         .operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(operator),
         .value = value
     };
@@ -1749,7 +1749,7 @@ yp_constant_path_write_node_create(yp_parser_t *parser, yp_constant_path_node_t
             .type = YP_NODE_CONSTANT_PATH_WRITE_NODE,
             .location = {
                 .start = target->base.location.start,
-                .end = (value == NULL ? target->base.location.end : value->location.end)
+                .end = value->location.end
             },
         },
         .target = target,
@@ -1848,7 +1848,7 @@ yp_constant_write_node_create(yp_parser_t *parser, yp_location_t *name_loc, cons
             .type = YP_NODE_CONSTANT_WRITE_NODE,
             .location = {
                 .start = name_loc->start,
-                .end = value != NULL ? value->location.end : name_loc->end
+                .end = value->location.end
             },
         },
         .name_loc = *name_loc,
@@ -2355,7 +2355,7 @@ yp_global_variable_write_node_create(yp_parser_t *parser, const yp_location_t *n
             .type = YP_NODE_GLOBAL_VARIABLE_WRITE_NODE,
             .location = {
                 .start = name_loc->start,
-                .end = (value == NULL ? name_loc->end : value->location.end)
+                .end = value->location.end
             },
         },
         .name_loc = *name_loc,
@@ -2710,7 +2710,7 @@ yp_instance_variable_write_node_create(yp_parser_t *parser, yp_instance_variable
             .type = YP_NODE_INSTANCE_VARIABLE_WRITE_NODE,
             .location = {
                 .start = read_node->base.location.start,
-                .end = value == NULL ? read_node->base.location.end : value->location.end
+                .end = value->location.end
             }
         },
         .name_loc = YP_LOCATION_NODE_BASE_VALUE(read_node),
@@ -3062,7 +3062,7 @@ yp_local_variable_write_node_create(yp_parser_t *parser, yp_constant_id_t consta
             .type = YP_NODE_LOCAL_VARIABLE_WRITE_NODE,
             .location = {
                 .start = name_loc->start,
-                .end = value == NULL ? name_loc->end : value->location.end
+                .end = value->location.end
             }
         },
         .constant_id = constant_id,
@@ -7810,55 +7810,42 @@ parse_starred_expression(yp_parser_t *parser, yp_binding_power_t binding_power,
 // Convert the given node into a valid target node.
 static yp_node_t *
 parse_target(yp_parser_t *parser, yp_node_t *target) {
-    yp_token_t operator = not_provided(parser);
-
     switch (YP_NODE_TYPE(target)) {
         case YP_NODE_MISSING_NODE:
             return target;
-        case YP_NODE_CLASS_VARIABLE_READ_NODE: {
+        case YP_NODE_CLASS_VARIABLE_READ_NODE:
-            yp_class_variable_write_node_t *write_node = yp_class_variable_read_node_to_class_variable_write_node(parser, (yp_class_variable_read_node_t *) target, &operator, NULL);
+            assert(sizeof(yp_class_variable_target_node_t) == sizeof(yp_class_variable_read_node_t));
-            yp_node_destroy(parser, target);
+            target->type = YP_NODE_CLASS_VARIABLE_TARGET_NODE;
-            return (yp_node_t *) write_node;
+            return target;
-        }
         case YP_NODE_CONSTANT_PATH_NODE:
-            return (yp_node_t *) yp_constant_path_write_node_create(parser, (yp_constant_path_node_t *) target, &operator, NULL);
+            assert(sizeof(yp_constant_path_target_node_t) == sizeof(yp_constant_path_node_t));
-        case YP_NODE_CONSTANT_READ_NODE: {
+            target->type = YP_NODE_CONSTANT_PATH_TARGET_NODE;
-            yp_constant_write_node_t *node = yp_constant_write_node_create(parser, &target->location, &operator, NULL);
+            return target;
-            yp_node_destroy(parser, target);
+        case YP_NODE_CONSTANT_READ_NODE:
-
+            assert(sizeof(yp_constant_target_node_t) == sizeof(yp_constant_read_node_t));
-            return (yp_node_t *) node;
+            target->type = YP_NODE_CONSTANT_TARGET_NODE;
-        }
+            return target;
         case YP_NODE_BACK_REFERENCE_READ_NODE:
+            assert(sizeof(yp_global_variable_target_node_t) == sizeof(yp_back_reference_read_node_t));
+            /* fallthrough */
         case YP_NODE_NUMBERED_REFERENCE_READ_NODE:
+            assert(sizeof(yp_global_variable_target_node_t) == sizeof(yp_numbered_reference_read_node_t));
             yp_diagnostic_list_append(&parser->error_list, target->location.start, target->location.end, "Can't set variable");
             /* fallthrough */
-        case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
+        case YP_NODE_GLOBAL_VARIABLE_READ_NODE:
-            yp_global_variable_write_node_t *result = yp_global_variable_write_node_create(parser, &target->location, &operator, NULL);
+            assert(sizeof(yp_global_variable_target_node_t) == sizeof(yp_global_variable_read_node_t));
-            yp_node_destroy(parser, target);
+            target->type = YP_NODE_GLOBAL_VARIABLE_TARGET_NODE;
-
+            return target;
-            return (yp_node_t *) result;
+        case YP_NODE_LOCAL_VARIABLE_READ_NODE:
-        }
+            assert(sizeof(yp_local_variable_target_node_t) == sizeof(yp_local_variable_read_node_t));
-        case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
+            target->type = YP_NODE_LOCAL_VARIABLE_TARGET_NODE;
-            yp_local_variable_read_node_t *local_read = (yp_local_variable_read_node_t *) target;
+            return target;
-
+        case YP_NODE_INSTANCE_VARIABLE_READ_NODE:
-            yp_constant_id_t constant_id = local_read->constant_id;
+            assert(sizeof(yp_instance_variable_target_node_t) == sizeof(yp_instance_variable_read_node_t));
-            uint32_t depth = local_read->depth;
+            target->type = YP_NODE_INSTANCE_VARIABLE_TARGET_NODE;
-
+            return target;
-            yp_location_t name_loc = target->location;
+        case YP_NODE_MULTI_WRITE_NODE:
-            yp_node_destroy(parser, target);
+            return target;
-
-            return (yp_node_t *) yp_local_variable_write_node_create(parser, constant_id, depth, NULL, &name_loc, &operator);
-        }
-        case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
-            yp_node_t *write_node = (yp_node_t *) yp_instance_variable_write_node_create(parser, (yp_instance_variable_read_node_t *) target, &operator, NULL);
-            yp_node_destroy(parser, target);
-            return write_node;
-        }
-        case YP_NODE_MULTI_WRITE_NODE: {
-            yp_multi_write_node_t *multi_write = (yp_multi_write_node_t *) target;
-            yp_multi_write_node_operator_loc_set(multi_write, &operator);
-            return (yp_node_t *) multi_write;
-        }
         case YP_NODE_SPLAT_NODE: {
             yp_splat_node_t *splat = (yp_splat_node_t *) target;
 
@@ -7866,7 +7853,9 @@ parse_target(yp_parser_t *parser, yp_node_t *target) {
                 splat->expression = parse_target(parser, splat->expression);
             }
 
+            yp_token_t operator = not_provided(parser);
             yp_location_t location = { .start = NULL, .end = NULL };
+
             yp_multi_write_node_t *multi_write = yp_multi_write_node_create(parser, &operator, NULL, &location, &location);
             yp_multi_write_node_targets_append(multi_write, (yp_node_t *) splat);
 
@@ -7874,6 +7863,7 @@ parse_target(yp_parser_t *parser, yp_node_t *target) {
         }
         case YP_NODE_CALL_NODE: {
             yp_call_node_t *call = (yp_call_node_t *) target;
+
             // If we have no arguments to the call node and we need this to be a
             // target then this is either a method call or a local variable write.
             if (
@@ -7896,8 +7886,11 @@ parse_target(yp_parser_t *parser, yp_node_t *target) {
                     yp_parser_local_add_location(parser, message.start, message.end);
                     yp_node_destroy(parser, target);
 
-                    yp_constant_id_t constant_id = yp_parser_constant_id_location(parser, message.start, message.end);
+                    const yp_token_t name = { .type = YP_TOKEN_IDENTIFIER, .start = message.start, .end = message.end };
-                    target = (yp_node_t *) yp_local_variable_write_node_create(parser, constant_id, 0, NULL, &message, &operator);
+                    target = (yp_node_t *) yp_local_variable_read_node_create(parser, &name, 0);
+
+                    assert(sizeof(yp_local_variable_target_node_t) == sizeof(yp_local_variable_read_node_t));
+                    target->type = YP_NODE_LOCAL_VARIABLE_TARGET_NODE;
 
                     if (token_is_numbered_parameter(message.start, message.end)) {
                         yp_diagnostic_list_append(&parser->error_list, message.start, message.end, "reserved for numbered parameter");
@@ -7940,10 +7933,10 @@ parse_target(yp_parser_t *parser, yp_node_t *target) {
         }
         /* fallthrough */
         default:
-            // In this case we have a node that we don't know how to convert into a
+            // In this case we have a node that we don't know how to convert
-            // target. We need to treat it as an error. For now, we'll mark it as an
+            // into a target. We need to treat it as an error. For now, we'll
-            // error and just skip right past it.
+            // mark it as an error and just skip right past it.
-            yp_diagnostic_list_append(&parser->error_list, operator.start, operator.end, "Unexpected `='.");
+            yp_diagnostic_list_append(&parser->error_list, target->location.start, target->location.end, "Unexpected write target.");
             return target;
     }
 }