1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[ruby/yarp] Flatten CallAndWriteNode, CallOrWriteNode, and CallOperatorWriteNode

Browse Source 
https://github.com/ruby/yarp/commit/8f26ffa0b2
This commit is contained in:
Kevin Newton 2023-09-05 14:16:33 -04:00 committed by git
parent 95e4bdcd62
commit 767f984017
21 changed files with 771 additions and 777 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
test/yarp/location_test.rb
View File

@ -172,9 +172,9 @@ module YARP
assert_location(CallNode, "foo bar('baz')") assert_location(CallNode, "foo bar('baz')")
end end
def test_CallOperatorAndWriteNode def test_CallAndWriteNode
assert_location(CallOperatorAndWriteNode, "foo.foo &&= bar") assert_location(CallAndWriteNode, "foo.foo &&= bar")
assert_location(CallOperatorAndWriteNode, "foo[foo] &&= bar") assert_location(CallAndWriteNode, "foo[foo] &&= bar")
end end
def test_CallOperatorWriteNode def test_CallOperatorWriteNode
@ -182,9 +182,9 @@ module YARP
assert_location(CallOperatorWriteNode, "foo[foo] += bar") assert_location(CallOperatorWriteNode, "foo[foo] += bar")
end end
def test_CallOperatorOrWriteNode def test_CallOrWriteNode
assert_location(CallOperatorOrWriteNode, "foo.foo ||= bar") assert_location(CallOrWriteNode, "foo.foo ||= bar")
assert_location(CallOperatorOrWriteNode, "foo[foo] ||= bar") assert_location(CallOrWriteNode, "foo[foo] ||= bar")
end end
def test_CapturePatternNode def test_CapturePatternNode

24
test/yarp/snapshots/seattlerb/index_0_opasgn.txt
View File

@ -2,20 +2,18 @@ ProgramNode(0...8)(
[], [],
StatementsNode(0...8)( StatementsNode(0...8)(
[CallOperatorWriteNode(0...8)( [CallOperatorWriteNode(0...8)(
CallNode(0...3)( CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"), nil,
nil, (1...3),
(1...3), (1...2),
(1...2), nil,
nil, (2...3),
(2...3), 0,
nil, "[]",
0, "[]=",
"[]=" :+,
),
(4...6), (4...6),
CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b"), CallNode(7...8)(nil, nil, (7...8), nil, nil, nil, nil, 2, "b")
:+
)] )]
) )
) )

26
test/yarp/snapshots/seattlerb/op_asgn_dot_ident_command_call.txt
View File

@ -1,18 +1,17 @@
ProgramNode(0...11)( ProgramNode(0...11)(
[], [],
StatementsNode(0...11)( StatementsNode(0...11)(
[CallOperatorOrWriteNode(0...11)( [CallOrWriteNode(0...11)(
CallNode(0...3)( ConstantReadNode(0...1)(),
ConstantReadNode(0...1)(), (1...2),
(1...2), (2...3),
(2...3), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "B",
0, "B=",
"B=" (4...7),
),
CallNode(8...11)( CallNode(8...11)(
nil, nil,
nil, nil,
@ -23,8 +22,7 @@ ProgramNode(0...11)(
nil, nil,
0, 0,
"c" "c"
), )
(4...7)
)] )]
) )
) )

26
test/yarp/snapshots/seattlerb/op_asgn_index_command_call.txt
View File

@ -1,18 +1,17 @@
ProgramNode(0...16)( ProgramNode(0...16)(
[], [],
StatementsNode(0...16)( StatementsNode(0...16)(
[CallOperatorOrWriteNode(0...16)( [CallOrWriteNode(0...16)(
CallNode(0...5)( CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"), nil,
nil, (1...5),
(1...5), (1...2),
(1...2), ArgumentsNode(2...4)([SymbolNode(2...4)((2...3), (3...4), nil, "b")]),
ArgumentsNode(2...4)([SymbolNode(2...4)((2...3), (3...4), nil, "b")]), (4...5),
(4...5), 0,
nil, "[]",
0, "[]=",
"[]=" (6...9),
),
CallNode(10...16)( CallNode(10...16)(
nil, nil,
nil, nil,
@ -25,8 +24,7 @@ ProgramNode(0...16)(
nil, nil,
0, 0,
"c" "c"
), )
(6...9)
)] )]
) )
) )

24
test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier1.txt
View File

@ -2,20 +2,18 @@ ProgramNode(0...9)(
[], [],
StatementsNode(0...9)( StatementsNode(0...9)(
[CallOperatorWriteNode(0...9)( [CallOperatorWriteNode(0...9)(
CallNode(0...4)( ConstantReadNode(0...1)(),
ConstantReadNode(0...1)(), (1...3),
(1...3), (3...4),
(3...4), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :+,
),
(5...7), (5...7),
IntegerNode(8...9)(), IntegerNode(8...9)()
:+
)] )]
) )
) )

24
test/yarp/snapshots/seattlerb/op_asgn_primary_colon_identifier_command_call.txt
View File

@ -2,17 +2,16 @@ ProgramNode(0...11)(
[], [],
StatementsNode(0...11)( StatementsNode(0...11)(
[CallOperatorWriteNode(0...11)( [CallOperatorWriteNode(0...11)(
CallNode(0...4)( ConstantReadNode(0...1)(),
ConstantReadNode(0...1)(), (1...3),
(1...3), (3...4),
(3...4), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :*,
),
(5...7), (5...7),
CallNode(8...11)( CallNode(8...11)(
nil, nil,
@ -26,8 +25,7 @@ ProgramNode(0...11)(
nil, nil,
0, 0,
"c" "c"
), )
:*
)] )]
) )
) )

26
test/yarp/snapshots/seattlerb/op_asgn_val_dot_ident_command_call.txt
View File

@ -1,18 +1,17 @@
ProgramNode(0...11)( ProgramNode(0...11)(
[], [],
StatementsNode(0...11)( StatementsNode(0...11)(
[CallOperatorOrWriteNode(0...11)( [CallOrWriteNode(0...11)(
CallNode(0...3)( CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"), (1...2),
(1...2), (2...3),
(2...3), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" (4...7),
),
CallNode(8...11)( CallNode(8...11)(
nil, nil,
nil, nil,
@ -23,8 +22,7 @@ ProgramNode(0...11)(
nil, nil,
0, 0,
"c" "c"
), )
(4...7)
)] )]
) )
) )

24
test/yarp/snapshots/seattlerb/safe_op_asgn.txt
View File

@ -2,17 +2,16 @@ ProgramNode(0...11)(
[], [],
StatementsNode(0...11)( StatementsNode(0...11)(
[CallOperatorWriteNode(0...11)( [CallOperatorWriteNode(0...11)(
CallNode(0...4)( CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"), (1...3),
(1...3), (3...4),
(3...4), nil,
nil, nil,
nil, nil,
nil, 1,
nil, "b",
1, "b=",
"b=" :+,
),
(5...7), (5...7),
CallNode(8...11)( CallNode(8...11)(
nil, nil,
@ -24,8 +23,7 @@ ProgramNode(0...11)(
nil, nil,
0, 0,
"x" "x"
), )
:+
)] )]
) )
) )

26
test/yarp/snapshots/seattlerb/safe_op_asgn2.txt
View File

@ -1,20 +1,18 @@
ProgramNode(0...10)( ProgramNode(0...10)(
[], [],
StatementsNode(0...10)( StatementsNode(0...10)(
[CallOperatorOrWriteNode(0...10)( [CallOrWriteNode(0...10)(
CallNode(0...4)( CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"), (1...3),
(1...3), (3...4),
(3...4), nil,
nil, nil,
nil, nil,
nil, 1,
nil, "b",
1, "b=",
"b=" (5...8),
), CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "x")
CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "x"),
(5...8)
)] )]
) )
) )

92
test/yarp/snapshots/unparser/corpus/literal/assignment.txt
View File

@ -584,32 +584,20 @@ ProgramNode(0...704)(
0, 0,
"[]=" "[]="
), ),
CallOperatorOrWriteNode(536...550)( CallOrWriteNode(536...550)(
CallNode(536...542)( LocalVariableReadNode(536...537)(:a, 0),
LocalVariableReadNode(536...537)(:a, 0), nil,
nil, (537...542),
(537...542), (537...538),
(537...538), ArgumentsNode(538...541)(
ArgumentsNode(538...541)( [StringNode(538...541)((538...540), (540...540), (540...541), "")]
[StringNode(538...541)((538...540), (540...540), (540...541), "")]
),
(541...542),
nil,
0,
"[]="
), ),
CallNode(547...550)( (541...542),
nil, 0,
nil, "[]",
(547...550), "[]=",
nil, (543...546),
nil, CallNode(547...550)(nil, nil, (547...550), nil, nil, nil, nil, 2, "bar")
nil,
nil,
2,
"bar"
),
(543...546)
), ),
InstanceVariableOrWriteNode(551...561)( InstanceVariableOrWriteNode(551...561)(
:@a, :@a,
@ -668,42 +656,26 @@ ProgramNode(0...704)(
0, 0,
"[]=" "[]="
), ),
CallOperatorOrWriteNode(651...672)( CallOrWriteNode(651...672)(
CallNode(651...664)( LocalVariableReadNode(651...652)(:a, 0),
LocalVariableReadNode(651...652)(:a, 0), nil,
nil, (652...664),
(652...664), (652...653),
(652...653), ArgumentsNode(653...663)(
ArgumentsNode(653...663)( [InterpolatedStringNode(653...663)(
[InterpolatedStringNode(653...663)( (653...663),
(653...663), [StringNode(673...675)(nil, (673...675), nil, " "),
[StringNode(673...675)(nil, (673...675), nil, " "), EmbeddedStatementsNode(675...678)((675...677), nil, (677...678)),
EmbeddedStatementsNode(675...678)( StringNode(678...679)(nil, (678...679), nil, "\n")],
(675...677), (679...687)
nil, )]
(677...678)
),
StringNode(678...679)(nil, (678...679), nil, "\n")],
(679...687)
)]
),
(663...664),
nil,
0,
"[]="
), ),
CallNode(669...672)( (663...664),
nil, 0,
nil, "[]",
(669...672), "[]=",
nil, (665...668),
nil, CallNode(669...672)(nil, nil, (669...672), nil, nil, nil, nil, 2, "bar")
nil,
nil,
2,
"bar"
),
(665...668)
), ),
InstanceVariableOrWriteNode(687...704)( InstanceVariableOrWriteNode(687...704)(
:@a, :@a,

524
test/yarp/snapshots/unparser/corpus/literal/opasgn.txt
View File

@ -105,334 +105,304 @@ ProgramNode(0...233)(
"[]=" "[]="
), ),
CallOperatorWriteNode(84...92)( CallOperatorWriteNode(84...92)(
CallNode(84...87)( LocalVariableReadNode(84...85)(:a, 0),
LocalVariableReadNode(84...85)(:a, 0), (85...86),
(85...86), (86...87),
(86...87), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :+,
),
(88...90), (88...90),
IntegerNode(91...92)(), IntegerNode(91...92)()
:+
), ),
CallOperatorWriteNode(93...101)( CallOperatorWriteNode(93...101)(
CallNode(93...96)( LocalVariableReadNode(93...94)(:a, 0),
LocalVariableReadNode(93...94)(:a, 0), (94...95),
(94...95), (95...96),
(95...96), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :-,
),
(97...99), (97...99),
IntegerNode(100...101)(), IntegerNode(100...101)()
:-
), ),
CallOperatorWriteNode(102...111)( CallOperatorWriteNode(102...111)(
CallNode(102...105)( LocalVariableReadNode(102...103)(:a, 0),
LocalVariableReadNode(102...103)(:a, 0), (103...104),
(103...104), (104...105),
(104...105), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :**,
),
(106...109), (106...109),
IntegerNode(110...111)(), IntegerNode(110...111)()
:**
), ),
CallOperatorWriteNode(112...120)( CallOperatorWriteNode(112...120)(
CallNode(112...115)( LocalVariableReadNode(112...113)(:a, 0),
LocalVariableReadNode(112...113)(:a, 0), (113...114),
(113...114), (114...115),
(114...115), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :*,
),
(116...118), (116...118),
IntegerNode(119...120)(), IntegerNode(119...120)()
:*
), ),
CallOperatorWriteNode(121...129)( CallOperatorWriteNode(121...129)(
CallNode(121...124)( LocalVariableReadNode(121...122)(:a, 0),
LocalVariableReadNode(121...122)(:a, 0), (122...123),
(122...123), (123...124),
(123...124), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" :/,
),
(125...127), (125...127),
IntegerNode(128...129)(), IntegerNode(128...129)()
:/
), ),
CallOperatorAndWriteNode(130...139)( CallAndWriteNode(130...139)(
CallNode(130...133)( LocalVariableReadNode(130...131)(:a, 0),
LocalVariableReadNode(130...131)(:a, 0), (131...132),
(131...132), (132...133),
(132...133), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b="
),
(134...137), (134...137),
CallNode(138...139)(nil, nil, (138...139), nil, nil, nil, nil, 2, "b") CallNode(138...139)(nil, nil, (138...139), nil, nil, nil, nil, 2, "b")
), ),
CallOperatorOrWriteNode(140...149)( CallOrWriteNode(140...149)(
CallNode(140...143)( LocalVariableReadNode(140...141)(:a, 0),
LocalVariableReadNode(140...141)(:a, 0), (141...142),
(141...142), (142...143),
(142...143), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "b",
0, "b=",
"b=" (144...147),
), IntegerNode(148...149)()
IntegerNode(148...149)(),
(144...147)
), ),
CallOperatorWriteNode(150...159)( CallOperatorWriteNode(150...159)(
CallNode(150...154)( LocalVariableReadNode(150...151)(:a, 0),
LocalVariableReadNode(150...151)(:a, 0), nil,
nil, (151...154),
(151...154), (151...152),
(151...152), ArgumentsNode(152...153)(
ArgumentsNode(152...153)( [CallNode(152...153)(
[CallNode(152...153)( nil,
nil, nil,
nil, (152...153),
(152...153), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(153...154),
nil,
0,
"[]="
), ),
(153...154),
0,
"[]",
"[]=",
:+,
(155...157), (155...157),
IntegerNode(158...159)(), IntegerNode(158...159)()
:+
), ),
CallOperatorWriteNode(160...169)( CallOperatorWriteNode(160...169)(
CallNode(160...164)( LocalVariableReadNode(160...161)(:a, 0),
LocalVariableReadNode(160...161)(:a, 0), nil,
nil, (161...164),
(161...164), (161...162),
(161...162), ArgumentsNode(162...163)(
ArgumentsNode(162...163)( [CallNode(162...163)(
[CallNode(162...163)( nil,
nil, nil,
nil, (162...163),
(162...163), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(163...164),
nil,
0,
"[]="
), ),
(163...164),
0,
"[]",
"[]=",
:-,
(165...167), (165...167),
IntegerNode(168...169)(), IntegerNode(168...169)()
:-
), ),
CallOperatorWriteNode(170...180)( CallOperatorWriteNode(170...180)(
CallNode(170...174)( LocalVariableReadNode(170...171)(:a, 0),
LocalVariableReadNode(170...171)(:a, 0), nil,
nil, (171...174),
(171...174), (171...172),
(171...172), ArgumentsNode(172...173)(
ArgumentsNode(172...173)( [CallNode(172...173)(
[CallNode(172...173)( nil,
nil, nil,
nil, (172...173),
(172...173), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(173...174),
nil,
0,
"[]="
), ),
(173...174),
0,
"[]",
"[]=",
:**,
(175...178), (175...178),
IntegerNode(179...180)(), IntegerNode(179...180)()
:**
), ),
CallOperatorWriteNode(181...190)( CallOperatorWriteNode(181...190)(
CallNode(181...185)( LocalVariableReadNode(181...182)(:a, 0),
LocalVariableReadNode(181...182)(:a, 0), nil,
nil, (182...185),
(182...185), (182...183),
(182...183), ArgumentsNode(183...184)(
ArgumentsNode(183...184)( [CallNode(183...184)(
[CallNode(183...184)( nil,
nil, nil,
nil, (183...184),
(183...184), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(184...185),
nil,
0,
"[]="
), ),
(184...185),
0,
"[]",
"[]=",
:*,
(186...188), (186...188),
IntegerNode(189...190)(), IntegerNode(189...190)()
:*
), ),
CallOperatorWriteNode(191...200)( CallOperatorWriteNode(191...200)(
CallNode(191...195)( LocalVariableReadNode(191...192)(:a, 0),
LocalVariableReadNode(191...192)(:a, 0), nil,
nil, (192...195),
(192...195), (192...193),
(192...193), ArgumentsNode(193...194)(
ArgumentsNode(193...194)( [CallNode(193...194)(
[CallNode(193...194)( nil,
nil, nil,
nil, (193...194),
(193...194), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(194...195),
nil,
0,
"[]="
), ),
(194...195),
0,
"[]",
"[]=",
:/,
(196...198), (196...198),
IntegerNode(199...200)(), IntegerNode(199...200)()
:/
), ),
CallOperatorAndWriteNode(201...211)( CallAndWriteNode(201...211)(
CallNode(201...205)( LocalVariableReadNode(201...202)(:a, 0),
LocalVariableReadNode(201...202)(:a, 0), nil,
nil, (202...205),
(202...205), (202...203),
(202...203), ArgumentsNode(203...204)(
ArgumentsNode(203...204)( [CallNode(203...204)(
[CallNode(203...204)( nil,
nil, nil,
nil, (203...204),
(203...204), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(204...205),
nil,
0,
"[]="
), ),
(204...205),
0,
"[]",
"[]=",
(206...209), (206...209),
CallNode(210...211)(nil, nil, (210...211), nil, nil, nil, nil, 2, "b") CallNode(210...211)(nil, nil, (210...211), nil, nil, nil, nil, 2, "b")
), ),
CallOperatorOrWriteNode(212...222)( CallOrWriteNode(212...222)(
CallNode(212...216)( LocalVariableReadNode(212...213)(:a, 0),
LocalVariableReadNode(212...213)(:a, 0), nil,
nil, (213...216),
(213...216), (213...214),
(213...214), ArgumentsNode(214...215)(
ArgumentsNode(214...215)( [CallNode(214...215)(
[CallNode(214...215)( nil,
nil, nil,
nil, (214...215),
(214...215), nil,
nil, nil,
nil, nil,
nil, nil,
nil, 2,
2, "b"
"b" )]
)]
),
(215...216),
nil,
0,
"[]="
), ),
IntegerNode(221...222)(), (215...216),
(217...220) 0,
"[]",
"[]=",
(217...220),
IntegerNode(221...222)()
), ),
CallOperatorWriteNode(223...233)( CallOperatorWriteNode(223...233)(
CallNode(223...228)( CallNode(223...226)(
CallNode(223...226)( nil,
nil, nil,
nil, (223...226),
(223...226),
nil,
nil,
nil,
nil,
2,
"foo"
),
(226...227),
(227...228),
nil, nil,
nil, nil,
nil, nil,
nil, nil,
0, 2,
"A=" "foo"
), ),
(226...227),
(227...228),
nil,
nil,
nil,
0,
"A",
"A=",
:+,
(229...231), (229...231),
IntegerNode(232...233)(), IntegerNode(232...233)()
:+
)] )]
) )
) )

46
test/yarp/snapshots/whitequark/and_asgn.txt
View File

@ -1,35 +1,31 @@
ProgramNode(0...28)( ProgramNode(0...28)(
[], [],
StatementsNode(0...28)( StatementsNode(0...28)(
[CallOperatorAndWriteNode(0...11)( [CallAndWriteNode(0...11)(
CallNode(0...5)( CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"), (3...4),
(3...4), (4...5),
(4...5), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "a",
0, "a=",
"a="
),
(6...9), (6...9),
IntegerNode(10...11)() IntegerNode(10...11)()
), ),
CallOperatorAndWriteNode(13...28)( CallAndWriteNode(13...28)(
CallNode(13...22)( CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"), nil,
nil, (16...22),
(16...22), (16...17),
(16...17), ArgumentsNode(17...21)(
ArgumentsNode(17...21)( [IntegerNode(17...18)(), IntegerNode(20...21)()]
[IntegerNode(17...18)(), IntegerNode(20...21)()]
),
(21...22),
nil,
0,
"[]="
), ),
(21...22),
0,
"[]",
"[]=",
(23...26), (23...26),
IntegerNode(27...28)() IntegerNode(27...28)()
)] )]

72
test/yarp/snapshots/whitequark/op_asgn.txt
View File

@ -2,52 +2,46 @@ ProgramNode(0...35)(
[], [],
StatementsNode(0...35)( StatementsNode(0...35)(
[CallOperatorWriteNode(0...10)( [CallOperatorWriteNode(0...10)(
CallNode(0...5)( CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"), (3...4),
(3...4), (4...5),
(4...5), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "A",
0, "A=",
"A=" :+,
),
(6...8), (6...8),
IntegerNode(9...10)(), IntegerNode(9...10)()
:+
), ),
CallOperatorWriteNode(12...22)( CallOperatorWriteNode(12...22)(
CallNode(12...17)( CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "foo"),
CallNode(12...15)(nil, nil, (12...15), nil, nil, nil, nil, 2, "foo"), (15...16),
(15...16), (16...17),
(16...17), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "a",
0, "a=",
"a=" :+,
),
(18...20), (18...20),
IntegerNode(21...22)(), IntegerNode(21...22)()
:+
), ),
CallOperatorWriteNode(24...35)( CallOperatorWriteNode(24...35)(
CallNode(24...30)( CallNode(24...27)(nil, nil, (24...27), nil, nil, nil, nil, 2, "foo"),
CallNode(24...27)(nil, nil, (24...27), nil, nil, nil, nil, 2, "foo"), (27...29),
(27...29), (29...30),
(29...30), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "a",
0, "a=",
"a=" :+,
),
(31...33), (31...33),
IntegerNode(34...35)(), IntegerNode(34...35)()
:+
)] )]
) )
) )

72
test/yarp/snapshots/whitequark/op_asgn_cmd.txt
View File

@ -2,17 +2,16 @@ ProgramNode(0...64)(
[], [],
StatementsNode(0...64)( StatementsNode(0...64)(
[CallOperatorWriteNode(0...14)( [CallOperatorWriteNode(0...14)(
CallNode(0...5)( CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"), (3...4),
(3...4), (4...5),
(4...5), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "A",
0, "A=",
"A=" :+,
),
(6...8), (6...8),
CallNode(9...14)( CallNode(9...14)(
nil, nil,
@ -36,21 +35,19 @@ ProgramNode(0...64)(
nil, nil,
0, 0,
"m" "m"
), )
:+
), ),
CallOperatorWriteNode(16...30)( CallOperatorWriteNode(16...30)(
CallNode(16...21)( CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "foo"),
CallNode(16...19)(nil, nil, (16...19), nil, nil, nil, nil, 2, "foo"), (19...20),
(19...20), (20...21),
(20...21), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "a",
0, "a=",
"a=" :+,
),
(22...24), (22...24),
CallNode(25...30)( CallNode(25...30)(
nil, nil,
@ -74,8 +71,7 @@ ProgramNode(0...64)(
nil, nil,
0, 0,
"m" "m"
), )
:+
), ),
ConstantPathOperatorWriteNode(32...47)( ConstantPathOperatorWriteNode(32...47)(
ConstantPathNode(32...38)( ConstantPathNode(32...38)(
@ -110,17 +106,16 @@ ProgramNode(0...64)(
:+ :+
), ),
CallOperatorWriteNode(49...64)( CallOperatorWriteNode(49...64)(
CallNode(49...55)( CallNode(49...52)(nil, nil, (49...52), nil, nil, nil, nil, 2, "foo"),
CallNode(49...52)(nil, nil, (49...52), nil, nil, nil, nil, 2, "foo"), (52...54),
(52...54), (54...55),
(54...55), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "a",
0, "a=",
"a=" :+,
),
(56...58), (56...58),
CallNode(59...64)( CallNode(59...64)(
nil, nil,
@ -144,8 +139,7 @@ ProgramNode(0...64)(
nil, nil,
0, 0,
"m" "m"
), )
:+
)] )]
) )
) )

24
test/yarp/snapshots/whitequark/op_asgn_index.txt
View File

@ -2,20 +2,18 @@ ProgramNode(0...14)(
[], [],
StatementsNode(0...14)( StatementsNode(0...14)(
[CallOperatorWriteNode(0...14)( [CallOperatorWriteNode(0...14)(
CallNode(0...9)( CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"), nil,
nil, (3...9),
(3...9), (3...4),
(3...4), ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]),
ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]), (8...9),
(8...9), 0,
nil, "[]",
0, "[]=",
"[]=" :+,
),
(10...12), (10...12),
IntegerNode(13...14)(), IntegerNode(13...14)()
:+
)] )]
) )
) )

24
test/yarp/snapshots/whitequark/op_asgn_index_cmd.txt
View File

@ -2,17 +2,16 @@ ProgramNode(0...18)(
[], [],
StatementsNode(0...18)( StatementsNode(0...18)(
[CallOperatorWriteNode(0...18)( [CallOperatorWriteNode(0...18)(
CallNode(0...9)( CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"), nil,
nil, (3...9),
(3...9), (3...4),
(3...4), ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]),
ArgumentsNode(4...8)([IntegerNode(4...5)(), IntegerNode(7...8)()]), (8...9),
(8...9), 0,
nil, "[]",
0, "[]=",
"[]=" :+,
),
(10...12), (10...12),
CallNode(13...18)( CallNode(13...18)(
nil, nil,
@ -36,8 +35,7 @@ ProgramNode(0...18)(
nil, nil,
0, 0,
"m" "m"
), )
:+
)] )]
) )
) )

54
test/yarp/snapshots/whitequark/or_asgn.txt
View File

@ -1,37 +1,33 @@
ProgramNode(0...28)( ProgramNode(0...28)(
[], [],
StatementsNode(0...28)( StatementsNode(0...28)(
[CallOperatorOrWriteNode(0...11)( [CallOrWriteNode(0...11)(
CallNode(0...5)( CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"),
CallNode(0...3)(nil, nil, (0...3), nil, nil, nil, nil, 2, "foo"), (3...4),
(3...4), (4...5),
(4...5), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "a",
0, "a=",
"a=" (6...9),
), IntegerNode(10...11)()
IntegerNode(10...11)(),
(6...9)
), ),
CallOperatorOrWriteNode(13...28)( CallOrWriteNode(13...28)(
CallNode(13...22)( CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"),
CallNode(13...16)(nil, nil, (13...16), nil, nil, nil, nil, 2, "foo"), nil,
nil, (16...22),
(16...22), (16...17),
(16...17), ArgumentsNode(17...21)(
ArgumentsNode(17...21)( [IntegerNode(17...18)(), IntegerNode(20...21)()]
[IntegerNode(17...18)(), IntegerNode(20...21)()]
),
(21...22),
nil,
0,
"[]="
), ),
IntegerNode(27...28)(), (21...22),
(23...26) 0,
"[]",
"[]=",
(23...26),
IntegerNode(27...28)()
)] )]
) )
) )

192
test/yarp/snapshots/whitequark/ruby_bug_12402.txt
View File

@ -136,17 +136,16 @@ ProgramNode(0...437)(
(91...92) (91...92)
), ),
CallOperatorWriteNode(116...145)( CallOperatorWriteNode(116...145)(
CallNode(116...121)( LocalVariableReadNode(116...119)(:foo, 0),
LocalVariableReadNode(116...119)(:foo, 0), (119...120),
(119...120), (120...121),
(120...121), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "C",
0, "C=",
"C=" :+,
),
(122...124), (122...124),
CallNode(125...145)( CallNode(125...145)(
nil, nil,
@ -174,21 +173,19 @@ ProgramNode(0...437)(
nil, nil,
0, 0,
"raise" "raise"
), )
:+
), ),
CallOperatorWriteNode(147...177)( CallOperatorWriteNode(147...177)(
CallNode(147...152)( LocalVariableReadNode(147...150)(:foo, 0),
LocalVariableReadNode(147...150)(:foo, 0), (150...151),
(150...151), (151...152),
(151...152), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "C",
0, "C=",
"C=" :+,
),
(153...155), (153...155),
RescueModifierNode(156...177)( RescueModifierNode(156...177)(
CallNode(156...166)( CallNode(156...166)(
@ -216,21 +213,19 @@ ProgramNode(0...437)(
), ),
(167...173), (167...173),
NilNode(174...177)() NilNode(174...177)()
), )
:+
), ),
CallOperatorWriteNode(179...208)( CallOperatorWriteNode(179...208)(
CallNode(179...184)( LocalVariableReadNode(179...182)(:foo, 0),
LocalVariableReadNode(179...182)(:foo, 0), (182...183),
(182...183), (183...184),
(183...184), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "m",
0, "m=",
"m=" :+,
),
(185...187), (185...187),
CallNode(188...208)( CallNode(188...208)(
nil, nil,
@ -258,21 +253,19 @@ ProgramNode(0...437)(
nil, nil,
0, 0,
"raise" "raise"
), )
:+
), ),
CallOperatorWriteNode(210...240)( CallOperatorWriteNode(210...240)(
CallNode(210...215)( LocalVariableReadNode(210...213)(:foo, 0),
LocalVariableReadNode(210...213)(:foo, 0), (213...214),
(213...214), (214...215),
(214...215), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "m",
0, "m=",
"m=" :+,
),
(216...218), (216...218),
RescueModifierNode(219...240)( RescueModifierNode(219...240)(
CallNode(219...229)( CallNode(219...229)(
@ -300,8 +293,7 @@ ProgramNode(0...437)(
), ),
(230...236), (230...236),
NilNode(237...240)() NilNode(237...240)()
), )
:+
), ),
ConstantPathOrWriteNode(242...273)( ConstantPathOrWriteNode(242...273)(
ConstantPathNode(242...248)( ConstantPathNode(242...248)(
@ -374,17 +366,16 @@ ProgramNode(0...437)(
) )
), ),
CallOperatorWriteNode(309...339)( CallOperatorWriteNode(309...339)(
CallNode(309...315)( LocalVariableReadNode(309...312)(:foo, 0),
LocalVariableReadNode(309...312)(:foo, 0), (312...314),
(312...314), (314...315),
(314...315), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "m",
0, "m=",
"m=" :+,
),
(316...318), (316...318),
CallNode(319...339)( CallNode(319...339)(
nil, nil,
@ -412,21 +403,19 @@ ProgramNode(0...437)(
nil, nil,
0, 0,
"raise" "raise"
), )
:+
), ),
CallOperatorWriteNode(341...372)( CallOperatorWriteNode(341...372)(
CallNode(341...347)( LocalVariableReadNode(341...344)(:foo, 0),
LocalVariableReadNode(341...344)(:foo, 0), (344...346),
(344...346), (346...347),
(346...347), nil,
nil, nil,
nil, nil,
nil, 0,
nil, "m",
0, "m=",
"m=" :+,
),
(348...350), (348...350),
RescueModifierNode(351...372)( RescueModifierNode(351...372)(
CallNode(351...361)( CallNode(351...361)(
@ -454,21 +443,19 @@ ProgramNode(0...437)(
), ),
(362...368), (362...368),
NilNode(369...372)() NilNode(369...372)()
), )
:+
), ),
CallOperatorWriteNode(374...404)( CallOperatorWriteNode(374...404)(
CallNode(374...380)( LocalVariableReadNode(374...377)(:foo, 0),
LocalVariableReadNode(374...377)(:foo, 0), nil,
nil, (377...380),
(377...380), (377...378),
(377...378), ArgumentsNode(378...379)([IntegerNode(378...379)()]),
ArgumentsNode(378...379)([IntegerNode(378...379)()]), (379...380),
(379...380), 0,
nil, "[]",
0, "[]=",
"[]=" :+,
),
(381...383), (381...383),
CallNode(384...404)( CallNode(384...404)(
nil, nil,
@ -496,21 +483,19 @@ ProgramNode(0...437)(
nil, nil,
0, 0,
"raise" "raise"
), )
:+
), ),
CallOperatorWriteNode(406...437)( CallOperatorWriteNode(406...437)(
CallNode(406...412)( LocalVariableReadNode(406...409)(:foo, 0),
LocalVariableReadNode(406...409)(:foo, 0), nil,
nil, (409...412),
(409...412), (409...410),
(409...410), ArgumentsNode(410...411)([IntegerNode(410...411)()]),
ArgumentsNode(410...411)([IntegerNode(410...411)()]), (411...412),
(411...412), 0,
nil, "[]",
0, "[]=",
"[]=" :+,
),
(413...415), (413...415),
RescueModifierNode(416...437)( RescueModifierNode(416...437)(
CallNode(416...426)( CallNode(416...426)(
@ -538,8 +523,7 @@ ProgramNode(0...437)(
), ),
(427...433), (427...433),
NilNode(434...437)() NilNode(434...437)()
), )
:+
)] )]
) )
) )

22
test/yarp/snapshots/whitequark/send_op_asgn_conditional.txt
View File

@ -1,18 +1,16 @@
ProgramNode(0...10)( ProgramNode(0...10)(
[], [],
StatementsNode(0...10)( StatementsNode(0...10)(
[CallOperatorAndWriteNode(0...10)( [CallAndWriteNode(0...10)(
CallNode(0...4)( CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"),
CallNode(0...1)(nil, nil, (0...1), nil, nil, nil, nil, 2, "a"), (1...3),
(1...3), (3...4),
(3...4), nil,
nil, nil,
nil, nil,
nil, 1,
nil, "b",
1, "b=",
"b="
),
(5...8), (5...8),
IntegerNode(9...10)() IntegerNode(9...10)()
)] )]

117
yarp/config.yml
View File

@ -591,6 +591,37 @@ nodes:
break foo break foo
^^^^^^^^^ ^^^^^^^^^
- name: CallAndWriteNode
fields:
- name: receiver
type: node?
- name: call_operator_loc
type: location?
- name: message_loc
type: location?
- name: opening_loc
type: location?
- name: arguments
type: node?
kind: ArgumentsNode
- name: closing_loc
type: location?
- name: flags
type: flags
kind: CallNodeFlags
- name: read_name
type: string
- name: write_name
type: string
- name: operator_loc
type: location
- name: value
type: node
comment: |
Represents the use of the `&&=` operator on a call.
foo.bar &&= value
^^^^^^^^^^^^^^^^^
- name: CallNode - name: CallNode
fields: fields:
- name: receiver - name: receiver
@ -634,50 +665,70 @@ nodes:
foo&.bar foo&.bar
^^^^^^^^ ^^^^^^^^
- name: CallOperatorAndWriteNode
fields:
- name: target
type: node
kind: CallNode
- name: operator_loc
type: location
- name: value
type: node
comment: |
Represents the use of the `&&=` operator on a call.
foo.bar &&= value
^^^^^^^^^^^^^^^^^
- name: CallOperatorOrWriteNode
fields:
- name: target
type: node
kind: CallNode
- name: value
type: node
- name: operator_loc
type: location
comment: |
Represents the use of the `||=` operator on a call.
foo.bar ||= value
^^^^^^^^^^^^^^^^^
- name: CallOperatorWriteNode - name: CallOperatorWriteNode
fields: fields:
- name: target - name: receiver
type: node type: node?
kind: CallNode - name: call_operator_loc
type: location?
- name: message_loc
type: location?
- name: opening_loc
type: location?
- name: arguments
type: node?
kind: ArgumentsNode
- name: closing_loc
type: location?
- name: flags
type: flags
kind: CallNodeFlags
- name: read_name
type: string
- name: write_name
type: string
- name: operator
type: constant
- name: operator_loc - name: operator_loc
type: location type: location
- name: value - name: value
type: node type: node
- name: operator
type: constant
comment: | comment: |
Represents the use of an assignment operator on a call. Represents the use of an assignment operator on a call.
foo.bar += baz foo.bar += baz
^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
- name: CallOrWriteNode
fields:
- name: receiver
type: node?
- name: call_operator_loc
type: location?
- name: message_loc
type: location?
- name: opening_loc
type: location?
- name: arguments
type: node?
kind: ArgumentsNode
- name: closing_loc
type: location?
- name: flags
type: flags
kind: CallNodeFlags
- name: read_name
type: string
- name: write_name
type: string
- name: operator_loc
type: location
- name: value
type: node
comment: |
Represents the use of the `||=` operator on a call.
foo.bar ||= value
^^^^^^^^^^^^^^^^^
- name: CapturePatternNode - name: CapturePatternNode
fields: fields:
- name: value - name: value

97
yarp/yarp.c
View File

@ -1451,69 +1451,128 @@ yp_call_node_variable_call_p(yp_call_node_t *node) {
return node->base.flags & YP_CALL_NODE_FLAGS_VARIABLE_CALL; return node->base.flags & YP_CALL_NODE_FLAGS_VARIABLE_CALL;
} }
// Allocate and initialize a new CallOperatorAndWriteNode node. // Initialize the read name by reading the write name and chopping off the '='.
static yp_call_operator_and_write_node_t * static void
yp_call_operator_and_write_node_create(yp_parser_t *parser, yp_call_node_t *target, const yp_token_t *operator, yp_node_t *value) { yp_call_write_read_name_init(yp_string_t *read_name, yp_string_t *write_name) {
assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); size_t length = write_name->length - 1;
yp_call_operator_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_call_operator_and_write_node_t);
*node = (yp_call_operator_and_write_node_t) { void *memory = malloc(length);
memcpy(memory, write_name->source, length);
yp_string_owned_init(read_name, (uint8_t *) memory, length);
}
// Allocate and initialize a new CallAndWriteNode node.
static yp_call_and_write_node_t *
yp_call_and_write_node_create(yp_parser_t *parser, yp_call_node_t *target, const yp_token_t *operator, yp_node_t *value) {
assert(target->block == NULL);
assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL);
yp_call_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_call_and_write_node_t);
*node = (yp_call_and_write_node_t) {
{ {
.type = YP_NODE_CALL_OPERATOR_AND_WRITE_NODE, .type = YP_NODE_CALL_AND_WRITE_NODE,
.flags = target->base.flags,
.location = { .location = {
.start = target->base.location.start, .start = target->base.location.start,
.end = value->location.end .end = value->location.end
} }
}, },
.target = target, .receiver = target->receiver,
.call_operator_loc = target->call_operator_loc,
.message_loc = target->message_loc,
.opening_loc = target->opening_loc,
.arguments = target->arguments,
.closing_loc = target->closing_loc,
.read_name = YP_EMPTY_STRING,
.write_name = target->name,
.operator_loc = YP_LOCATION_TOKEN_VALUE(operator), .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
.value = value .value = value
}; };
yp_call_write_read_name_init(&node->read_name, &node->write_name);
// Here we're going to free the target, since it is no longer necessary.
// However, we don't want to call `yp_node_destroy` because we want to keep
// around all of its children since we just reused them.
free(target);
return node; return node;
} }
// Allocate a new CallOperatorWriteNode node. // Allocate a new CallOperatorWriteNode node.
static yp_call_operator_write_node_t * static yp_call_operator_write_node_t *
yp_call_operator_write_node_create(yp_parser_t *parser, yp_call_node_t *target, const yp_token_t *operator, yp_node_t *value) { yp_call_operator_write_node_create(yp_parser_t *parser, yp_call_node_t *target, const yp_token_t *operator, yp_node_t *value) {
assert(target->block == NULL);
yp_call_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_call_operator_write_node_t); yp_call_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_call_operator_write_node_t);
*node = (yp_call_operator_write_node_t) { *node = (yp_call_operator_write_node_t) {
{ {
.type = YP_NODE_CALL_OPERATOR_WRITE_NODE, .type = YP_NODE_CALL_OPERATOR_WRITE_NODE,
.flags = target->base.flags,
.location = { .location = {
.start = target->base.location.start, .start = target->base.location.start,
.end = value->location.end .end = value->location.end
} }
}, },
.target = target, .receiver = target->receiver,
.call_operator_loc = target->call_operator_loc,
.message_loc = target->message_loc,
.opening_loc = target->opening_loc,
.arguments = target->arguments,
.closing_loc = target->closing_loc,
.read_name = YP_EMPTY_STRING,
.write_name = target->name,
.operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1),
.operator_loc = YP_LOCATION_TOKEN_VALUE(operator), .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
.value = value, .value = value
.operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1)
}; };
yp_call_write_read_name_init(&node->read_name, &node->write_name);
// Here we're going to free the target, since it is no longer necessary.
// However, we don't want to call `yp_node_destroy` because we want to keep
// around all of its children since we just reused them.
free(target);
return node; return node;
} }
// Allocate and initialize a new CallOperatorOrWriteNode node. // Allocate and initialize a new CallOperatorOrWriteNode node.
static yp_call_operator_or_write_node_t * static yp_call_or_write_node_t *
yp_call_operator_or_write_node_create(yp_parser_t *parser, yp_call_node_t *target, const yp_token_t *operator, yp_node_t *value) { yp_call_or_write_node_create(yp_parser_t *parser, yp_call_node_t *target, const yp_token_t *operator, yp_node_t *value) {
assert(target->block == NULL);
assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL);
yp_call_operator_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_call_operator_or_write_node_t); yp_call_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_call_or_write_node_t);
*node = (yp_call_operator_or_write_node_t) { *node = (yp_call_or_write_node_t) {
{ {
.type = YP_NODE_CALL_OPERATOR_OR_WRITE_NODE, .type = YP_NODE_CALL_OR_WRITE_NODE,
.flags = target->base.flags,
.location = { .location = {
.start = target->base.location.start, .start = target->base.location.start,
.end = value->location.end .end = value->location.end
} }
}, },
.target = target, .receiver = target->receiver,
.call_operator_loc = target->call_operator_loc,
.message_loc = target->message_loc,
.opening_loc = target->opening_loc,
.arguments = target->arguments,
.closing_loc = target->closing_loc,
.read_name = YP_EMPTY_STRING,
.write_name = target->name,
.operator_loc = YP_LOCATION_TOKEN_VALUE(operator), .operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
.value = value .value = value
}; };
yp_call_write_read_name_init(&node->read_name, &node->write_name);
// Here we're going to free the target, since it is no longer necessary.
// However, we don't want to call `yp_node_destroy` because we want to keep
// around all of its children since we just reused them.
free(target);
return node; return node;
} }
@ -12996,7 +13055,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
node = parse_target(parser, node); node = parse_target(parser, node);
yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&=");
return (yp_node_t *) yp_call_operator_and_write_node_create(parser, (yp_call_node_t *) node, &token, value); return (yp_node_t *) yp_call_and_write_node_create(parser, (yp_call_node_t *) node, &token, value);
} }
case YP_NODE_MULTI_WRITE_NODE: { case YP_NODE_MULTI_WRITE_NODE: {
parser_lex(parser); parser_lex(parser);
@ -13097,7 +13156,7 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t
node = parse_target(parser, node); node = parse_target(parser, node);
yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||=");
return (yp_node_t *) yp_call_operator_or_write_node_create(parser, (yp_call_node_t *) node, &token, value); return (yp_node_t *) yp_call_or_write_node_create(parser, (yp_call_node_t *) node, &token, value);
} }
case YP_NODE_MULTI_WRITE_NODE: { case YP_NODE_MULTI_WRITE_NODE: {
parser_lex(parser); parser_lex(parser);