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

[ruby/yarp] Multi target nodes

Browse Source 
https://github.com/ruby/yarp/commit/fa53fe88e4
This commit is contained in:
Kevin Newton 2023-09-07 13:00:45 -04:00 committed by git
parent be21a056d2
commit f39b576e76
46 changed files with 983 additions and 911 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
test/yarp/location_test.rb
View File

@ -223,7 +223,7 @@ module YARP
def test_ClassVariableTargetNode def test_ClassVariableTargetNode
assert_location(ClassVariableTargetNode, "@@foo, @@bar = baz", 0...5) do |node| assert_location(ClassVariableTargetNode, "@@foo, @@bar = baz", 0...5) do |node|
node.targets.first node.target.targets.first
end end
end end
@ -251,7 +251,7 @@ module YARP
def test_ConstantPathTargetNode def test_ConstantPathTargetNode
assert_location(ConstantPathTargetNode, "::Foo, ::Bar = baz", 0...5) do |node| assert_location(ConstantPathTargetNode, "::Foo, ::Bar = baz", 0...5) do |node|
node.targets.first node.target.targets.first
end end
end end
@ -280,7 +280,7 @@ module YARP
def test_ConstantTargetNode def test_ConstantTargetNode
assert_location(ConstantTargetNode, "Foo, Bar = baz", 0...3) do |node| assert_location(ConstantTargetNode, "Foo, Bar = baz", 0...3) do |node|
node.targets.first node.target.targets.first
end end
end end
@ -378,7 +378,7 @@ module YARP
def test_GlobalVariableTargetNode def test_GlobalVariableTargetNode
assert_location(GlobalVariableTargetNode, "$foo, $bar = baz", 0...4) do |node| assert_location(GlobalVariableTargetNode, "$foo, $bar = baz", 0...4) do |node|
node.targets.first node.target.targets.first
end end
end end
@ -430,7 +430,7 @@ module YARP
def test_InstanceVariableTargetNode def test_InstanceVariableTargetNode
assert_location(InstanceVariableTargetNode, "@foo, @bar = baz", 0...4) do |node| assert_location(InstanceVariableTargetNode, "@foo, @bar = baz", 0...4) do |node|
node.targets.first node.target.targets.first
end end
end end
@ -517,7 +517,7 @@ module YARP
def test_LocalVariableTargetNode def test_LocalVariableTargetNode
assert_location(LocalVariableTargetNode, "foo, bar = baz", 0...3) do |node| assert_location(LocalVariableTargetNode, "foo, bar = baz", 0...3) do |node|
node.targets.first node.target.targets.first
end end
end end
@ -537,6 +537,11 @@ module YARP
assert_location(ModuleNode, "module Foo end") assert_location(ModuleNode, "module Foo end")
end end
def test_MultiTargetNode
assert_location(MultiTargetNode, "for foo, bar in baz do end", 4...12, &:index)
assert_location(MultiTargetNode, "foo, bar = baz", 0...8, &:target)
end
def test_MultiWriteNode def test_MultiWriteNode
assert_location(MultiWriteNode, "foo, bar = baz") assert_location(MultiWriteNode, "foo, bar = baz")
end end
@ -690,7 +695,7 @@ module YARP
end end
def test_SplatNode def test_SplatNode
assert_location(SplatNode, "*foo = bar", 0...4) { |node| node.targets.first } assert_location(SplatNode, "*foo = bar", 0...4) { |node| node.target.targets.first }
end end
def test_StatementsNode def test_StatementsNode

82
test/yarp/snapshots/arrays.txt
View File

@ -317,56 +317,58 @@ ProgramNode(0...511)(
"[]=" "[]="
), ),
MultiWriteNode(191...212)( MultiWriteNode(191...212)(
[CallNode(191...197)( MultiTargetNode(191...205)(
CallNode(191...194)( [CallNode(191...197)(
CallNode(191...194)(
nil,
nil,
(191...194),
nil,
nil,
nil,
nil,
2,
"foo"
),
nil, nil,
(194...197),
(194...195),
ArgumentsNode(195...196)([IntegerNode(195...196)()]),
(196...197),
nil, nil,
(191...194), 0,
nil, "[]="
nil,
nil,
nil,
2,
"foo"
), ),
nil, CallNode(199...205)(
(194...197), CallNode(199...202)(
(194...195), nil,
ArgumentsNode(195...196)([IntegerNode(195...196)()]), nil,
(196...197), (199...202),
nil, nil,
0, nil,
"[]=" nil,
), nil,
CallNode(199...205)( 2,
CallNode(199...202)( "bar"
),
nil, nil,
(202...205),
(202...203),
ArgumentsNode(203...204)([IntegerNode(203...204)()]),
(204...205),
nil, nil,
(199...202), 0,
nil, "[]="
nil, )],
nil, nil,
nil, nil
2, ),
"bar"
),
nil,
(202...205),
(202...203),
ArgumentsNode(203...204)([IntegerNode(203...204)()]),
(204...205),
nil,
0,
"[]="
)],
(206...207), (206...207),
ArrayNode(208...212)( ArrayNode(208...212)(
[IntegerNode(208...209)(), IntegerNode(211...212)()], [IntegerNode(208...209)(), IntegerNode(211...212)()],
nil, nil,
nil nil
), )
nil,
nil
), ),
CallNode(214...233)( CallNode(214...233)(
CallNode(214...217)( CallNode(214...217)(

24
test/yarp/snapshots/for.txt
View File

@ -2,11 +2,9 @@ ProgramNode(0...143)(
[:i, :j, :k], [:i, :j, :k],
StatementsNode(0...143)( StatementsNode(0...143)(
[ForNode(0...20)( [ForNode(0...20)(
MultiWriteNode(4...5)( MultiTargetNode(4...5)(
[LocalVariableTargetNode(4...5)(:i, 0)], [LocalVariableTargetNode(4...5)(:i, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
RangeNode(9...14)( RangeNode(9...14)(
@ -22,11 +20,9 @@ ProgramNode(0...143)(
(17...20) (17...20)
), ),
ForNode(22...44)( ForNode(22...44)(
MultiWriteNode(26...27)( MultiTargetNode(26...27)(
[LocalVariableTargetNode(26...27)(:i, 0)], [LocalVariableTargetNode(26...27)(:i, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
RangeNode(31...36)( RangeNode(31...36)(
@ -42,12 +38,10 @@ ProgramNode(0...143)(
(41...44) (41...44)
), ),
ForNode(46...68)( ForNode(46...68)(
MultiWriteNode(50...53)( MultiTargetNode(50...53)(
[LocalVariableTargetNode(50...51)(:i, 0), [LocalVariableTargetNode(50...51)(:i, 0),
LocalVariableTargetNode(52...53)(:j, 0)], LocalVariableTargetNode(52...53)(:j, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
RangeNode(57...62)( RangeNode(57...62)(
@ -63,13 +57,11 @@ ProgramNode(0...143)(
(65...68) (65...68)
), ),
ForNode(70...94)( ForNode(70...94)(
MultiWriteNode(74...79)( MultiTargetNode(74...79)(
[LocalVariableTargetNode(74...75)(:i, 0), [LocalVariableTargetNode(74...75)(:i, 0),
LocalVariableTargetNode(76...77)(:j, 0), LocalVariableTargetNode(76...77)(:j, 0),
LocalVariableTargetNode(78...79)(:k, 0)], LocalVariableTargetNode(78...79)(:k, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
RangeNode(83...88)( RangeNode(83...88)(
@ -85,11 +77,9 @@ ProgramNode(0...143)(
(91...94) (91...94)
), ),
ForNode(96...119)( ForNode(96...119)(
MultiWriteNode(100...101)( MultiTargetNode(100...101)(
[LocalVariableTargetNode(100...101)(:i, 0)], [LocalVariableTargetNode(100...101)(:i, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
RangeNode(105...110)( RangeNode(105...110)(
@ -105,11 +95,9 @@ ProgramNode(0...143)(
(116...119) (116...119)
), ),
ForNode(121...143)( ForNode(121...143)(
MultiWriteNode(125...126)( MultiTargetNode(125...126)(
[LocalVariableTargetNode(125...126)(:i, 0)], [LocalVariableTargetNode(125...126)(:i, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
RangeNode(130...135)( RangeNode(130...135)(

74
test/yarp/snapshots/method_calls.txt
View File

@ -348,56 +348,58 @@ ProgramNode(0...1237)(
"b" "b"
), ),
MultiWriteNode(181...204)( MultiWriteNode(181...204)(
[CallNode(181...188)( MultiTargetNode(181...197)(
CallNode(181...184)( [CallNode(181...188)(
nil, CallNode(181...184)(
nil, nil,
(181...184), nil,
(181...184),
nil,
nil,
nil,
nil,
2,
"foo"
),
(184...185),
(185...188),
nil, nil,
nil, nil,
nil, nil,
nil, nil,
2, 0,
"foo" "foo="
), ),
(184...185), CallNode(190...197)(
(185...188), CallNode(190...193)(
nil, nil,
nil, nil,
nil, (190...193),
nil, nil,
0, nil,
"foo=" nil,
), nil,
CallNode(190...197)( 2,
CallNode(190...193)( "bar"
nil, ),
nil, (193...194),
(190...193), (194...197),
nil, nil,
nil, nil,
nil, nil,
nil, nil,
2, 0,
"bar" "bar="
), )],
(193...194), nil,
(194...197), nil
nil, ),
nil,
nil,
nil,
0,
"bar="
)],
(198...199), (198...199),
ArrayNode(200...204)( ArrayNode(200...204)(
[IntegerNode(200...201)(), IntegerNode(203...204)()], [IntegerNode(200...201)(), IntegerNode(203...204)()],
nil, nil,
nil nil
), )
nil,
nil
), ),
CallNode(206...210)( CallNode(206...210)(
CallNode(206...207)(nil, nil, (206...207), nil, nil, nil, nil, 2, "a"), CallNode(206...207)(nil, nil, (206...207), nil, nil, nil, nil, 2, "a"),

18
test/yarp/snapshots/seattlerb/masgn_anon_splat_arg.txt
View File

@ -2,18 +2,14 @@ ProgramNode(0...8)(
[:a], [:a],
StatementsNode(0...8)( StatementsNode(0...8)(
[MultiWriteNode(0...8)( [MultiWriteNode(0...8)(
[MultiWriteNode(0...1)( MultiTargetNode(0...4)(
[SplatNode(0...1)((0...1), nil)], [MultiTargetNode(0...1)([SplatNode(0...1)((0...1), nil)], nil, nil),
nil, LocalVariableTargetNode(3...4)(:a, 0)],
nil, nil,
nil, nil
nil ),
),
LocalVariableTargetNode(3...4)(:a, 0)],
(5...6), (5...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")
nil,
nil
)] )]
) )
) )

32
test/yarp/snapshots/seattlerb/masgn_arg_colon_arg.txt
View File

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

32
test/yarp/snapshots/seattlerb/masgn_arg_ident.txt
View File

@ -2,22 +2,24 @@ ProgramNode(0...10)(
[:a], [:a],
StatementsNode(0...10)( StatementsNode(0...10)(
[MultiWriteNode(0...10)( [MultiWriteNode(0...10)(
[LocalVariableTargetNode(0...1)(:a, 0), MultiTargetNode(0...6)(
CallNode(3...6)( [LocalVariableTargetNode(0...1)(:a, 0),
CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"), CallNode(3...6)(
(4...5), CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
(5...6), (4...5),
nil, (5...6),
nil, nil,
nil, nil,
nil, nil,
0, nil,
"C=" 0,
)], "C="
)],
nil,
nil
),
(7...8), (7...8),
CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "d"), CallNode(9...10)(nil, nil, (9...10), nil, nil, nil, nil, 2, "d")
nil,
nil
)] )]
) )
) )

14
test/yarp/snapshots/seattlerb/masgn_arg_splat_arg.txt
View File

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

20
test/yarp/snapshots/seattlerb/masgn_colon2.txt
View File

@ -2,20 +2,22 @@ ProgramNode(0...14)(
[:a], [:a],
StatementsNode(0...14)( StatementsNode(0...14)(
[MultiWriteNode(0...14)( [MultiWriteNode(0...14)(
[LocalVariableTargetNode(0...1)(:a, 0), MultiTargetNode(0...7)(
ConstantPathTargetNode(3...7)( [LocalVariableTargetNode(0...1)(:a, 0),
CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"), ConstantPathTargetNode(3...7)(
ConstantReadNode(6...7)(:C), CallNode(3...4)(nil, nil, (3...4), nil, nil, nil, nil, 2, "b"),
(4...6) ConstantReadNode(6...7)(:C),
)], (4...6)
)],
nil,
nil
),
(8...9), (8...9),
ArrayNode(10...14)( ArrayNode(10...14)(
[IntegerNode(10...11)(), IntegerNode(13...14)()], [IntegerNode(10...11)(), IntegerNode(13...14)()],
nil, nil,
nil nil
), )
nil,
nil
)] )]
) )
) )

28
test/yarp/snapshots/seattlerb/masgn_colon3.txt
View File

@ -2,24 +2,26 @@ ProgramNode(0...15)(
[], [],
StatementsNode(0...15)( StatementsNode(0...15)(
[MultiWriteNode(0...15)( [MultiWriteNode(0...15)(
[ConstantPathTargetNode(0...3)( MultiTargetNode(0...8)(
nil, [ConstantPathTargetNode(0...3)(
ConstantReadNode(2...3)(:A), nil,
(0...2) ConstantReadNode(2...3)(:A),
), (0...2)
ConstantPathTargetNode(5...8)( ),
nil, ConstantPathTargetNode(5...8)(
ConstantReadNode(7...8)(:B), nil,
(5...7) ConstantReadNode(7...8)(:B),
)], (5...7)
)],
nil,
nil
),
(9...10), (9...10),
ArrayNode(11...15)( ArrayNode(11...15)(
[IntegerNode(11...12)(), IntegerNode(14...15)()], [IntegerNode(11...12)(), IntegerNode(14...15)()],
nil, nil,
nil nil
), )
nil,
nil
)] )]
) )
) )

11
test/yarp/snapshots/seattlerb/masgn_command_call.txt
View File

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

28
test/yarp/snapshots/seattlerb/masgn_double_paren.txt
View File

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

10
test/yarp/snapshots/seattlerb/masgn_lhs_splat.txt
View File

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

12
test/yarp/snapshots/seattlerb/masgn_paren.txt
View File

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

22
test/yarp/snapshots/seattlerb/masgn_splat_arg.txt
View File

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

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

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

6
test/yarp/snapshots/seattlerb/masgn_star.txt
View File

@ -2,11 +2,9 @@ ProgramNode(0...5)(
[], [],
StatementsNode(0...5)( StatementsNode(0...5)(
[MultiWriteNode(0...5)( [MultiWriteNode(0...5)(
[SplatNode(0...1)((0...1), nil)], MultiTargetNode(0...1)([SplatNode(0...1)((0...1), nil)], nil, nil),
(2...3), (2...3),
IntegerNode(4...5)(), IntegerNode(4...5)()
nil,
nil
)] )]
) )
) )

14
test/yarp/snapshots/seattlerb/masgn_var_star_var.txt
View File

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

16
test/yarp/snapshots/seattlerb/mlhs_back_anonsplat.txt
View File

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

19
test/yarp/snapshots/seattlerb/mlhs_back_splat.txt
View File

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

22
test/yarp/snapshots/seattlerb/mlhs_front_anonsplat.txt
View File

@ -2,20 +2,16 @@ ProgramNode(0...14)(
[:x, :y, :z], [:x, :y, :z],
StatementsNode(0...14)( StatementsNode(0...14)(
[MultiWriteNode(0...14)( [MultiWriteNode(0...14)(
[MultiWriteNode(0...1)( MultiTargetNode(0...10)(
[SplatNode(0...1)((0...1), nil)], [MultiTargetNode(0...1)([SplatNode(0...1)((0...1), nil)], nil, nil),
nil, LocalVariableTargetNode(3...4)(:x, 0),
nil, LocalVariableTargetNode(6...7)(:y, 0),
nil, LocalVariableTargetNode(9...10)(:z, 0)],
nil nil,
), nil
LocalVariableTargetNode(3...4)(:x, 0), ),
LocalVariableTargetNode(6...7)(:y, 0),
LocalVariableTargetNode(9...10)(:z, 0)],
(11...12), (11...12),
CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "f"), CallNode(13...14)(nil, nil, (13...14), nil, nil, nil, nil, 2, "f")
nil,
nil
)] )]
) )
) )

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

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

22
test/yarp/snapshots/seattlerb/mlhs_mid_anonsplat.txt
View File

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

22
test/yarp/snapshots/seattlerb/mlhs_mid_splat.txt
View File

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

12
test/yarp/snapshots/seattlerb/mlhs_rescue.txt
View File

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

12
test/yarp/snapshots/seattlerb/parse_line_to_ary.txt
View File

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

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

@ -8,90 +8,102 @@ ProgramNode(0...704)(
(3...4) (3...4)
), ),
MultiWriteNode(7...24)( MultiWriteNode(7...24)(
[GlobalVariableTargetNode(8...10)(:$a), MultiTargetNode(7...15)(
GlobalVariableTargetNode(12...14)(:$b)], [GlobalVariableTargetNode(8...10)(:$a),
GlobalVariableTargetNode(12...14)(:$b)],
(7...8),
(14...15)
),
(16...17), (16...17),
ArrayNode(18...24)( ArrayNode(18...24)(
[IntegerNode(19...20)(), IntegerNode(22...23)()], [IntegerNode(19...20)(), IntegerNode(22...23)()],
(18...19), (18...19),
(23...24) (23...24)
), )
(7...8),
(14...15)
), ),
MultiWriteNode(25...38)( MultiWriteNode(25...38)(
[MultiWriteNode(26...30)( MultiTargetNode(25...34)(
[LocalVariableTargetNode(27...28)(:a, 0), [MultiTargetNode(26...30)(
SplatNode(28...29)((28...29), nil)], [LocalVariableTargetNode(27...28)(:a, 0),
nil, SplatNode(28...29)((28...29), nil)],
nil, (26...27),
(26...27), (29...30)
(29...30) ),
), LocalVariableTargetNode(32...33)(:b, 0)],
LocalVariableTargetNode(32...33)(:b, 0)], (25...26),
(33...34)
),
(35...36), (35...36),
IntegerNode(37...38)(), IntegerNode(37...38)()
(25...26),
(33...34)
), ),
MultiWriteNode(39...48)( MultiWriteNode(39...48)(
[SplatNode(40...42)( MultiTargetNode(39...43)(
(40...41), [SplatNode(40...42)(
LocalVariableTargetNode(41...42)(:a, 0) (40...41),
)], LocalVariableTargetNode(41...42)(:a, 0)
)],
(39...40),
(42...43)
),
(44...45), (44...45),
ArrayNode(46...48)([], (46...47), (47...48)), ArrayNode(46...48)([], (46...47), (47...48))
(39...40),
(42...43)
), ),
MultiWriteNode(49...64)( MultiWriteNode(49...64)(
[SplatNode(50...54)( MultiTargetNode(49...55)(
(50...51), [SplatNode(50...54)(
LocalVariableTargetNode(51...54)(:foo, 0) (50...51),
)], LocalVariableTargetNode(51...54)(:foo, 0)
)],
(49...50),
(54...55)
),
(56...57), (56...57),
ArrayNode(58...64)( ArrayNode(58...64)(
[IntegerNode(59...60)(), IntegerNode(62...63)()], [IntegerNode(59...60)(), IntegerNode(62...63)()],
(58...59), (58...59),
(63...64) (63...64)
), )
(49...50),
(54...55)
), ),
MultiWriteNode(65...84)( MultiWriteNode(65...84)(
[ClassVariableTargetNode(66...69)(:@@a), MultiTargetNode(65...75)(
ClassVariableTargetNode(71...74)(:@@b)], [ClassVariableTargetNode(66...69)(:@@a),
ClassVariableTargetNode(71...74)(:@@b)],
(65...66),
(74...75)
),
(76...77), (76...77),
ArrayNode(78...84)( ArrayNode(78...84)(
[IntegerNode(79...80)(), IntegerNode(82...83)()], [IntegerNode(79...80)(), IntegerNode(82...83)()],
(78...79), (78...79),
(83...84) (83...84)
), )
(65...66),
(74...75)
), ),
MultiWriteNode(85...102)( MultiWriteNode(85...102)(
[InstanceVariableTargetNode(86...88)(:@a), MultiTargetNode(85...93)(
InstanceVariableTargetNode(90...92)(:@b)], [InstanceVariableTargetNode(86...88)(:@a),
InstanceVariableTargetNode(90...92)(:@b)],
(85...86),
(92...93)
),
(94...95), (94...95),
ArrayNode(96...102)( ArrayNode(96...102)(
[IntegerNode(97...98)(), IntegerNode(100...101)()], [IntegerNode(97...98)(), IntegerNode(100...101)()],
(96...97), (96...97),
(101...102) (101...102)
), )
(85...86),
(92...93)
), ),
MultiWriteNode(103...128)( MultiWriteNode(103...128)(
[LocalVariableTargetNode(104...105)(:a, 0), MultiTargetNode(103...114)(
MultiWriteNode(107...113)( [LocalVariableTargetNode(104...105)(:a, 0),
[LocalVariableTargetNode(108...109)(:b, 0), MultiTargetNode(107...113)(
LocalVariableTargetNode(111...112)(:c, 0)], [LocalVariableTargetNode(108...109)(:b, 0),
nil, LocalVariableTargetNode(111...112)(:c, 0)],
nil, (107...108),
(107...108), (112...113)
(112...113) )],
)], (103...104),
(113...114)
),
(115...116), (115...116),
ArrayNode(117...128)( ArrayNode(117...128)(
[IntegerNode(118...119)(), [IntegerNode(118...119)(),
@ -102,185 +114,201 @@ ProgramNode(0...704)(
)], )],
(117...118), (117...118),
(127...128) (127...128)
), )
(103...104),
(113...114)
), ),
MultiWriteNode(129...144)( MultiWriteNode(129...144)(
[LocalVariableTargetNode(130...131)(:a, 0), MultiTargetNode(129...135)(
SplatNode(133...134)((133...134), nil)], [LocalVariableTargetNode(130...131)(:a, 0),
SplatNode(133...134)((133...134), nil)],
(129...130),
(134...135)
),
(136...137), (136...137),
ArrayNode(138...144)( ArrayNode(138...144)(
[IntegerNode(139...140)(), IntegerNode(142...143)()], [IntegerNode(139...140)(), IntegerNode(142...143)()],
(138...139), (138...139),
(143...144) (143...144)
), )
(129...130),
(134...135)
), ),
MultiWriteNode(145...163)( MultiWriteNode(145...163)(
[LocalVariableTargetNode(146...147)(:a, 0), MultiTargetNode(145...154)(
SplatNode(149...153)( [LocalVariableTargetNode(146...147)(:a, 0),
(149...150), SplatNode(149...153)(
LocalVariableTargetNode(150...153)(:foo, 0) (149...150),
)], LocalVariableTargetNode(150...153)(:foo, 0)
)],
(145...146),
(153...154)
),
(155...156), (155...156),
ArrayNode(157...163)( ArrayNode(157...163)(
[IntegerNode(158...159)(), IntegerNode(161...162)()], [IntegerNode(158...159)(), IntegerNode(161...162)()],
(157...158), (157...158),
(162...163) (162...163)
), )
(145...146),
(153...154)
), ),
MultiWriteNode(164...179)( MultiWriteNode(164...179)(
[LocalVariableTargetNode(165...166)(:a, 0), MultiTargetNode(164...170)(
LocalVariableTargetNode(168...169)(:b, 0)], [LocalVariableTargetNode(165...166)(:a, 0),
LocalVariableTargetNode(168...169)(:b, 0)],
(164...165),
(169...170)
),
(171...172), (171...172),
ArrayNode(173...179)( ArrayNode(173...179)(
[IntegerNode(174...175)(), IntegerNode(177...178)()], [IntegerNode(174...175)(), IntegerNode(177...178)()],
(173...174), (173...174),
(178...179) (178...179)
), )
(164...165),
(169...170)
), ),
MultiWriteNode(180...192)( MultiWriteNode(180...192)(
[LocalVariableTargetNode(181...182)(:a, 0), MultiTargetNode(180...186)(
LocalVariableTargetNode(184...185)(:b, 0)], [LocalVariableTargetNode(181...182)(:a, 0),
LocalVariableTargetNode(184...185)(:b, 0)],
(180...181),
(185...186)
),
(187...188), (187...188),
LocalVariableReadNode(189...192)(:foo, 0), LocalVariableReadNode(189...192)(:foo, 0)
(180...181),
(185...186)
), ),
MultiWriteNode(193...203)( MultiWriteNode(193...203)(
[LocalVariableTargetNode(194...195)(:a, 0), MultiTargetNode(193...197)(
SplatNode(195...196)((195...196), nil)], [LocalVariableTargetNode(194...195)(:a, 0),
SplatNode(195...196)((195...196), nil)],
(193...194),
(196...197)
),
(198...199), (198...199),
LocalVariableReadNode(200...203)(:foo, 0), LocalVariableReadNode(200...203)(:foo, 0)
(193...194),
(196...197)
), ),
MultiWriteNode(204...227)( MultiWriteNode(204...227)(
[CallNode(205...210)( MultiTargetNode(204...218)(
LocalVariableReadNode(205...206)(:a, 0), [CallNode(205...210)(
(206...207), LocalVariableReadNode(205...206)(:a, 0),
(207...210), (206...207),
nil, (207...210),
nil,
nil,
nil,
0,
"foo="
),
CallNode(212...217)(
LocalVariableReadNode(212...213)(:a, 0),
(213...214),
(214...217),
nil,
nil,
nil,
nil,
0,
"bar="
)],
(219...220),
ArrayNode(221...227)(
[IntegerNode(222...223)(), IntegerNode(225...226)()],
(221...222),
(226...227)
),
(204...205),
(217...218)
),
MultiWriteNode(228...252)(
[CallNode(229...236)(
LocalVariableReadNode(229...230)(:a, 0),
nil,
(230...236),
(230...231),
ArgumentsNode(231...235)(
[SplatNode(231...235)(
(231...232),
LocalVariableReadNode(232...235)(:foo, 0)
)]
),
(235...236),
nil,
0,
"[]="
),
CallNode(238...242)(
LocalVariableReadNode(238...239)(:a, 0),
nil,
(239...242),
(239...240),
ArgumentsNode(240...241)([IntegerNode(240...241)()]),
(241...242),
nil,
0,
"[]="
)],
(244...245),
ArrayNode(246...252)(
[IntegerNode(247...248)(), IntegerNode(250...251)()],
(246...247),
(251...252)
),
(228...229),
(242...243)
),
MultiWriteNode(253...274)(
[CallNode(254...258)(
LocalVariableReadNode(254...255)(:a, 0),
nil,
(255...258),
(255...256),
ArgumentsNode(256...257)([IntegerNode(256...257)()]),
(257...258),
nil,
0,
"[]="
),
CallNode(260...264)(
LocalVariableReadNode(260...261)(:a, 0),
nil,
(261...264),
(261...262),
ArgumentsNode(262...263)([IntegerNode(262...263)()]),
(263...264),
nil,
0,
"[]="
)],
(266...267),
ArrayNode(268...274)(
[IntegerNode(269...270)(), IntegerNode(272...273)()],
(268...269),
(273...274)
),
(253...254),
(264...265)
),
MultiWriteNode(275...287)(
[SplatNode(276...282)(
(276...277),
CallNode(277...282)(
LocalVariableReadNode(277...278)(:c, 0),
(278...279),
(279...282),
nil, nil,
nil, nil,
nil, nil,
nil, nil,
0, 0,
"foo=" "foo="
) ),
)], CallNode(212...217)(
LocalVariableReadNode(212...213)(:a, 0),
(213...214),
(214...217),
nil,
nil,
nil,
nil,
0,
"bar="
)],
(204...205),
(217...218)
),
(219...220),
ArrayNode(221...227)(
[IntegerNode(222...223)(), IntegerNode(225...226)()],
(221...222),
(226...227)
)
),
MultiWriteNode(228...252)(
MultiTargetNode(228...243)(
[CallNode(229...236)(
LocalVariableReadNode(229...230)(:a, 0),
nil,
(230...236),
(230...231),
ArgumentsNode(231...235)(
[SplatNode(231...235)(
(231...232),
LocalVariableReadNode(232...235)(:foo, 0)
)]
),
(235...236),
nil,
0,
"[]="
),
CallNode(238...242)(
LocalVariableReadNode(238...239)(:a, 0),
nil,
(239...242),
(239...240),
ArgumentsNode(240...241)([IntegerNode(240...241)()]),
(241...242),
nil,
0,
"[]="
)],
(228...229),
(242...243)
),
(244...245),
ArrayNode(246...252)(
[IntegerNode(247...248)(), IntegerNode(250...251)()],
(246...247),
(251...252)
)
),
MultiWriteNode(253...274)(
MultiTargetNode(253...265)(
[CallNode(254...258)(
LocalVariableReadNode(254...255)(:a, 0),
nil,
(255...258),
(255...256),
ArgumentsNode(256...257)([IntegerNode(256...257)()]),
(257...258),
nil,
0,
"[]="
),
CallNode(260...264)(
LocalVariableReadNode(260...261)(:a, 0),
nil,
(261...264),
(261...262),
ArgumentsNode(262...263)([IntegerNode(262...263)()]),
(263...264),
nil,
0,
"[]="
)],
(253...254),
(264...265)
),
(266...267),
ArrayNode(268...274)(
[IntegerNode(269...270)(), IntegerNode(272...273)()],
(268...269),
(273...274)
)
),
MultiWriteNode(275...287)(
MultiTargetNode(275...283)(
[SplatNode(276...282)(
(276...277),
CallNode(277...282)(
LocalVariableReadNode(277...278)(:c, 0),
(278...279),
(279...282),
nil,
nil,
nil,
nil,
0,
"foo="
)
)],
(275...276),
(282...283)
),
(284...285), (284...285),
IntegerNode(286...287)(), IntegerNode(286...287)()
(275...276),
(282...283)
), ),
ConstantPathWriteNode(288...301)( ConstantPathWriteNode(288...301)(
ConstantPathNode(288...293)( ConstantPathNode(288...293)(
@ -333,12 +361,14 @@ ProgramNode(0...704)(
ParenthesesNode(355...367)( ParenthesesNode(355...367)(
StatementsNode(356...366)( StatementsNode(356...366)(
[MultiWriteNode(356...366)( [MultiWriteNode(356...366)(
[LocalVariableTargetNode(357...358)(:b, 0), MultiTargetNode(356...362)(
LocalVariableTargetNode(360...361)(:c, 0)], [LocalVariableTargetNode(357...358)(:b, 0),
LocalVariableTargetNode(360...361)(:c, 0)],
(356...357),
(361...362)
),
(363...364), (363...364),
IntegerNode(365...366)(), IntegerNode(365...366)()
(356...357),
(361...362)
)] )]
), ),
(355...356), (355...356),

12
test/yarp/snapshots/unparser/corpus/literal/defined.txt
View File

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

16
test/yarp/snapshots/unparser/corpus/literal/for.txt
View File

@ -8,11 +8,9 @@ ProgramNode(0...119)(
(3...4), (3...4),
ArgumentsNode(4...29)( ArgumentsNode(4...29)(
[ForNode(4...29)( [ForNode(4...29)(
MultiWriteNode(8...9)( MultiTargetNode(8...9)(
[LocalVariableTargetNode(8...9)(:a, 0)], [LocalVariableTargetNode(8...9)(:a, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
CallNode(13...16)( CallNode(13...16)(
@ -51,11 +49,9 @@ ProgramNode(0...119)(
"bar" "bar"
), ),
ForNode(31...56)( ForNode(31...56)(
MultiWriteNode(35...36)( MultiTargetNode(35...36)(
[LocalVariableTargetNode(35...36)(:a, 0)], [LocalVariableTargetNode(35...36)(:a, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
CallNode(40...43)(nil, nil, (40...43), nil, nil, nil, nil, 2, "bar"), CallNode(40...43)(nil, nil, (40...43), nil, nil, nil, nil, 2, "bar"),
@ -68,14 +64,12 @@ ProgramNode(0...119)(
(53...56) (53...56)
), ),
ForNode(57...88)( ForNode(57...88)(
MultiWriteNode(61...68)( MultiTargetNode(61...68)(
[LocalVariableTargetNode(62...63)(:a, 0), [LocalVariableTargetNode(62...63)(:a, 0),
SplatNode(65...67)( SplatNode(65...67)(
(65...66), (65...66),
LocalVariableTargetNode(66...67)(:b, 0) LocalVariableTargetNode(66...67)(:b, 0)
)], )],
nil,
nil,
(61...62), (61...62),
(67...68) (67...68)
), ),
@ -89,11 +83,9 @@ ProgramNode(0...119)(
(85...88) (85...88)
), ),
ForNode(89...119)( ForNode(89...119)(
MultiWriteNode(93...99)( MultiTargetNode(93...99)(
[LocalVariableTargetNode(94...95)(:a, 0), [LocalVariableTargetNode(94...95)(:a, 0),
LocalVariableTargetNode(97...98)(:b, 0)], LocalVariableTargetNode(97...98)(:b, 0)],
nil,
nil,
(93...94), (93...94),
(98...99) (98...99)
), ),

12
test/yarp/snapshots/unparser/corpus/literal/send.txt
View File

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

102
test/yarp/snapshots/variables.txt
View File

@ -9,12 +9,14 @@ ProgramNode(0...293)(
(13...14) (13...14)
), ),
MultiWriteNode(18...34)( MultiWriteNode(18...34)(
[ClassVariableTargetNode(18...23)(:@@foo), MultiTargetNode(18...30)(
ClassVariableTargetNode(25...30)(:@@bar)], [ClassVariableTargetNode(18...23)(:@@foo),
ClassVariableTargetNode(25...30)(:@@bar)],
nil,
nil
),
(31...32), (31...32),
IntegerNode(33...34)(), IntegerNode(33...34)()
nil,
nil
), ),
ClassVariableWriteNode(36...48)( ClassVariableWriteNode(36...48)(
:@@foo, :@@foo,
@ -49,12 +51,14 @@ ProgramNode(0...293)(
(89...90) (89...90)
), ),
MultiWriteNode(94...108)( MultiWriteNode(94...108)(
[GlobalVariableTargetNode(94...98)(:$foo), MultiTargetNode(94...104)(
GlobalVariableTargetNode(100...104)(:$bar)], [GlobalVariableTargetNode(94...98)(:$foo),
GlobalVariableTargetNode(100...104)(:$bar)],
nil,
nil
),
(105...106), (105...106),
IntegerNode(107...108)(), IntegerNode(107...108)()
nil,
nil
), ),
GlobalVariableWriteNode(110...121)( GlobalVariableWriteNode(110...121)(
:$foo, :$foo,
@ -67,12 +71,14 @@ ProgramNode(0...293)(
(115...116) (115...116)
), ),
MultiWriteNode(123...137)( MultiWriteNode(123...137)(
[InstanceVariableTargetNode(123...127)(:@foo), MultiTargetNode(123...133)(
InstanceVariableTargetNode(129...133)(:@bar)], [InstanceVariableTargetNode(123...127)(:@foo),
InstanceVariableTargetNode(129...133)(:@bar)],
nil,
nil
),
(134...135), (134...135),
IntegerNode(136...137)(), IntegerNode(136...137)()
nil,
nil
), ),
InstanceVariableWriteNode(139...150)( InstanceVariableWriteNode(139...150)(
:@foo, :@foo,
@ -114,54 +120,62 @@ ProgramNode(0...293)(
(177...178) (177...178)
), ),
MultiWriteNode(185...198)( MultiWriteNode(185...198)(
[LocalVariableTargetNode(185...188)(:foo, 0), MultiTargetNode(185...191)(
SplatNode(190...191)((190...191), nil)], [LocalVariableTargetNode(185...188)(:foo, 0),
SplatNode(190...191)((190...191), nil)],
nil,
nil
),
(192...193), (192...193),
ArrayNode(194...198)( ArrayNode(194...198)(
[IntegerNode(194...195)(), IntegerNode(197...198)()], [IntegerNode(194...195)(), IntegerNode(197...198)()],
nil, nil,
nil nil
), )
nil,
nil
), ),
MultiWriteNode(200...211)( MultiWriteNode(200...211)(
[LocalVariableTargetNode(200...203)(:foo, 0), MultiTargetNode(200...204)(
SplatNode(203...204)((203...204), nil)], [LocalVariableTargetNode(200...203)(:foo, 0),
SplatNode(203...204)((203...204), nil)],
nil,
nil
),
(205...206), (205...206),
ArrayNode(207...211)( ArrayNode(207...211)(
[IntegerNode(207...208)(), IntegerNode(210...211)()], [IntegerNode(207...208)(), IntegerNode(210...211)()],
nil, nil,
nil nil
), )
nil,
nil
), ),
MultiWriteNode(213...229)( MultiWriteNode(213...229)(
[LocalVariableTargetNode(213...216)(:foo, 0), MultiTargetNode(213...222)(
SplatNode(218...222)( [LocalVariableTargetNode(213...216)(:foo, 0),
(218...219), SplatNode(218...222)(
LocalVariableTargetNode(219...222)(:bar, 0) (218...219),
)], LocalVariableTargetNode(219...222)(:bar, 0)
)],
nil,
nil
),
(223...224), (223...224),
ArrayNode(225...229)( ArrayNode(225...229)(
[IntegerNode(225...226)(), IntegerNode(228...229)()], [IntegerNode(225...226)(), IntegerNode(228...229)()],
nil, nil,
nil nil
), )
nil,
nil
), ),
MultiWriteNode(231...258)( MultiWriteNode(231...258)(
[LocalVariableTargetNode(231...234)(:foo, 0), MultiTargetNode(231...246)(
MultiWriteNode(236...246)( [LocalVariableTargetNode(231...234)(:foo, 0),
[LocalVariableTargetNode(237...240)(:bar, 0), MultiTargetNode(236...246)(
LocalVariableTargetNode(242...245)(:baz, 0)], [LocalVariableTargetNode(237...240)(:bar, 0),
nil, LocalVariableTargetNode(242...245)(:baz, 0)],
nil, (236...237),
(236...237), (245...246)
(245...246) )],
)], nil,
nil
),
(247...248), (247...248),
ArrayNode(249...258)( ArrayNode(249...258)(
[IntegerNode(249...250)(), [IntegerNode(249...250)(),
@ -172,9 +186,7 @@ ProgramNode(0...293)(
)], )],
nil, nil,
nil nil
), )
nil,
nil
), ),
LocalVariableWriteNode(260...270)( LocalVariableWriteNode(260...270)(
:foo, :foo,

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

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

12
test/yarp/snapshots/whitequark/cond_begin_masgn.txt
View File

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

8
test/yarp/snapshots/whitequark/for.txt
View File

@ -2,11 +2,9 @@ ProgramNode(0...48)(
[:a], [:a],
StatementsNode(0...48)( StatementsNode(0...48)(
[ForNode(0...24)( [ForNode(0...24)(
MultiWriteNode(4...5)( MultiTargetNode(4...5)(
[LocalVariableTargetNode(4...5)(:a, 0)], [LocalVariableTargetNode(4...5)(:a, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
CallNode(9...12)(nil, nil, (9...12), nil, nil, nil, nil, 2, "foo"), CallNode(9...12)(nil, nil, (9...12), nil, nil, nil, nil, 2, "foo"),
@ -29,11 +27,9 @@ ProgramNode(0...48)(
(21...24) (21...24)
), ),
ForNode(26...48)( ForNode(26...48)(
MultiWriteNode(30...31)( MultiTargetNode(30...31)(
[LocalVariableTargetNode(30...31)(:a, 0)], [LocalVariableTargetNode(30...31)(:a, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
CallNode(35...38)(nil, nil, (35...38), nil, nil, nil, nil, 2, "foo"), CallNode(35...38)(nil, nil, (35...38), nil, nil, nil, nil, 2, "foo"),

4
test/yarp/snapshots/whitequark/for_mlhs.txt
View File

@ -2,12 +2,10 @@ ProgramNode(0...28)(
[:a, :b], [:a, :b],
StatementsNode(0...28)( StatementsNode(0...28)(
[ForNode(0...28)( [ForNode(0...28)(
MultiWriteNode(4...8)( MultiTargetNode(4...8)(
[LocalVariableTargetNode(4...5)(:a, 0), [LocalVariableTargetNode(4...5)(:a, 0),
LocalVariableTargetNode(7...8)(:b, 0)], LocalVariableTargetNode(7...8)(:b, 0)],
nil, nil,
nil,
nil,
nil nil
), ),
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"),

12
test/yarp/snapshots/whitequark/if_masgn__24.txt
View File

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

38
test/yarp/snapshots/whitequark/masgn.txt
View File

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

118
test/yarp/snapshots/whitequark/masgn_attr.txt
View File

@ -2,70 +2,76 @@ ProgramNode(0...63)(
[:foo], [:foo],
StatementsNode(0...63)( StatementsNode(0...63)(
[MultiWriteNode(0...17)( [MultiWriteNode(0...17)(
[CallNode(0...6)( MultiTargetNode(0...11)(
SelfNode(0...4)(), [CallNode(0...6)(
(4...5), SelfNode(0...4)(),
(5...6), (4...5),
nil, (5...6),
nil, nil,
nil, nil,
nil, nil,
0, nil,
"A=" 0,
), "A="
LocalVariableTargetNode(8...11)(:foo, 0)], ),
LocalVariableTargetNode(8...11)(:foo, 0)],
nil,
nil
),
(12...13), (12...13),
LocalVariableReadNode(14...17)(:foo, 0), LocalVariableReadNode(14...17)(:foo, 0)
nil,
nil
), ),
MultiWriteNode(19...43)( MultiWriteNode(19...43)(
[CallNode(19...25)( MultiTargetNode(19...37)(
SelfNode(19...23)(), [CallNode(19...25)(
(23...24), SelfNode(19...23)(),
(24...25), (23...24),
nil, (24...25),
nil, nil,
nil, nil,
nil, nil,
0, nil,
"a=" 0,
), "a="
CallNode(27...37)(
SelfNode(27...31)(),
nil,
(31...37),
(31...32),
ArgumentsNode(32...36)(
[IntegerNode(32...33)(), IntegerNode(35...36)()]
), ),
(36...37), CallNode(27...37)(
nil, SelfNode(27...31)(),
0, nil,
"[]=" (31...37),
)], (31...32),
ArgumentsNode(32...36)(
[IntegerNode(32...33)(), IntegerNode(35...36)()]
),
(36...37),
nil,
0,
"[]="
)],
nil,
nil
),
(38...39), (38...39),
LocalVariableReadNode(40...43)(:foo, 0), LocalVariableReadNode(40...43)(:foo, 0)
nil,
nil
), ),
MultiWriteNode(45...63)( MultiWriteNode(45...63)(
[CallNode(45...52)( MultiTargetNode(45...57)(
SelfNode(45...49)(), [CallNode(45...52)(
(49...51), SelfNode(45...49)(),
(51...52), (49...51),
nil, (51...52),
nil, nil,
nil, nil,
nil, nil,
0, nil,
"a=" 0,
), "a="
LocalVariableTargetNode(54...57)(:foo, 0)], ),
LocalVariableTargetNode(54...57)(:foo, 0)],
nil,
nil
),
(58...59), (58...59),
LocalVariableReadNode(60...63)(:foo, 0), LocalVariableReadNode(60...63)(:foo, 0)
nil,
nil
)] )]
) )
) )

12
test/yarp/snapshots/whitequark/masgn_cmd.txt
View File

@ -2,8 +2,12 @@ ProgramNode(0...16)(
[:foo, :bar], [:foo, :bar],
StatementsNode(0...16)( StatementsNode(0...16)(
[MultiWriteNode(0...16)( [MultiWriteNode(0...16)(
[LocalVariableTargetNode(0...3)(:foo, 0), MultiTargetNode(0...8)(
LocalVariableTargetNode(5...8)(:bar, 0)], [LocalVariableTargetNode(0...3)(:foo, 0),
LocalVariableTargetNode(5...8)(:bar, 0)],
nil,
nil
),
(9...10), (9...10),
CallNode(11...16)( CallNode(11...16)(
nil, nil,
@ -15,9 +19,7 @@ ProgramNode(0...16)(
nil, nil,
0, 0,
"m" "m"
), )
nil,
nil
)] )]
) )
) )

40
test/yarp/snapshots/whitequark/masgn_const.txt
View File

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

52
test/yarp/snapshots/whitequark/masgn_nested.txt
View File

@ -1,34 +1,34 @@
ProgramNode(0...30)( ProgramNode(1...30)(
[:b, :a, :c], [:b, :a, :c],
StatementsNode(0...30)( StatementsNode(1...30)(
[MultiWriteNode(0...13)( [MultiWriteNode(1...13)(
[MultiWriteNode(1...6)( MultiTargetNode(1...6)(
[LocalVariableTargetNode(2...3)(:b, 0), [MultiTargetNode(1...6)(
SplatNode(3...4)((3...4), nil)], [LocalVariableTargetNode(2...3)(:b, 0),
nil, SplatNode(3...4)((3...4), nil)],
nil, (1...2),
(1...2), (5...6)
(5...6) )],
)], nil,
nil
),
(8...9), (8...9),
CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "foo"), CallNode(10...13)(nil, nil, (10...13), nil, nil, nil, nil, 2, "foo")
(0...1),
(6...7)
), ),
MultiWriteNode(15...30)( MultiWriteNode(15...30)(
[LocalVariableTargetNode(15...16)(:a, 0), MultiTargetNode(15...24)(
MultiWriteNode(18...24)( [LocalVariableTargetNode(15...16)(:a, 0),
[LocalVariableTargetNode(19...20)(:b, 0), MultiTargetNode(18...24)(
LocalVariableTargetNode(22...23)(:c, 0)], [LocalVariableTargetNode(19...20)(:b, 0),
nil, LocalVariableTargetNode(22...23)(:c, 0)],
nil, (18...19),
(18...19), (23...24)
(23...24) )],
)], nil,
nil
),
(25...26), (25...26),
CallNode(27...30)(nil, nil, (27...30), nil, nil, nil, nil, 2, "foo"), CallNode(27...30)(nil, nil, (27...30), nil, nil, nil, nil, 2, "foo")
nil,
nil
)] )]
) )
) )

178
test/yarp/snapshots/whitequark/masgn_splat.txt
View File

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

12
test/yarp/snapshots/whitequark/not_masgn__24.txt
View File

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

12
test/yarp/snapshots/whitequark/rescue_mod_masgn.txt
View File

@ -2,8 +2,12 @@ ProgramNode(0...29)(
[:foo, :bar], [:foo, :bar],
StatementsNode(0...29)( StatementsNode(0...29)(
[MultiWriteNode(0...29)( [MultiWriteNode(0...29)(
[LocalVariableTargetNode(0...3)(:foo, 0), MultiTargetNode(0...8)(
LocalVariableTargetNode(5...8)(:bar, 0)], [LocalVariableTargetNode(0...3)(:foo, 0),
LocalVariableTargetNode(5...8)(:bar, 0)],
nil,
nil
),
(9...10), (9...10),
RescueModifierNode(11...29)( RescueModifierNode(11...29)(
CallNode(11...15)(nil, nil, (11...15), nil, nil, nil, nil, 2, "meth"), CallNode(11...15)(nil, nil, (11...15), nil, nil, nil, nil, 2, "meth"),
@ -13,9 +17,7 @@ ProgramNode(0...29)(
(23...24), (23...24),
(28...29) (28...29)
) )
), )
nil,
nil
)] )]
) )
) )

20
yarp/config.yml
View File

@ -1751,14 +1751,10 @@ nodes:
module Foo end module Foo end
^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
- name: MultiWriteNode - name: MultiTargetNode
fields: fields:
- name: targets - name: targets
type: node[] type: node[]
- name: operator_loc
type: location?
- name: value
type: node?
- name: lparen_loc - name: lparen_loc
type: location? type: location?
- name: rparen_loc - name: rparen_loc
@ -1766,6 +1762,20 @@ nodes:
comment: | comment: |
Represents a multi-target expression. Represents a multi-target expression.
a, b, c = 1, 2, 3
^^^^^^^
- name: MultiWriteNode
fields:
- name: target
type: node
kind: MultiTargetNode
- name: operator_loc
type: location
- name: value
type: node
comment: |
Represents a write to a multi-target expression.
a, b, c = 1, 2, 3 a, b, c = 1, 2, 3
^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
- name: NextNode - name: NextNode

163
yarp/yarp.c
View File

@ -3320,32 +3320,27 @@ yp_module_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const
return node; return node;
} }
// Allocate a new MultiWriteNode node. // Allocate and initialize new MultiTargetNode node.
static yp_multi_write_node_t * static yp_multi_target_node_t *
yp_multi_write_node_create(yp_parser_t *parser, const yp_token_t *operator, yp_node_t *value, const yp_location_t *lparen_loc, const yp_location_t *rparen_loc) { yp_multi_target_node_create(yp_parser_t *parser) {
yp_multi_write_node_t *node = YP_ALLOC_NODE(parser, yp_multi_write_node_t); yp_multi_target_node_t *node = YP_ALLOC_NODE(parser, yp_multi_target_node_t);
*node = (yp_multi_write_node_t) { *node = (yp_multi_target_node_t) {
{ {
.type = YP_MULTI_WRITE_NODE, .type = YP_MULTI_TARGET_NODE,
.location = { .location = { .start = NULL, .end = NULL }
.start = lparen_loc->start,
.end = value == NULL ? rparen_loc->end : value->location.end
},
}, },
.operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(operator), .targets = YP_EMPTY_NODE_LIST,
.value = value, .lparen_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE,
.lparen_loc = *lparen_loc, .rparen_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE
.rparen_loc = *rparen_loc,
.targets = YP_EMPTY_NODE_LIST
}; };
return node; return node;
} }
// Append a target to a MultiWriteNode node. // Append a target to a MultiTargetNode node.
static void static void
yp_multi_write_node_targets_append(yp_multi_write_node_t *node, yp_node_t *target) { yp_multi_target_node_targets_append(yp_multi_target_node_t *node, yp_node_t *target) {
yp_node_list_append(&node->targets, target); yp_node_list_append(&node->targets, target);
if (node->base.location.start == NULL || (node->base.location.start > target->location.start)) { if (node->base.location.start == NULL || (node->base.location.start > target->location.start)) {
@ -3357,9 +3352,25 @@ yp_multi_write_node_targets_append(yp_multi_write_node_t *node, yp_node_t *targe
} }
} }
static inline void // Allocate a new MultiWriteNode node.
yp_multi_write_node_operator_loc_set(yp_multi_write_node_t *node, const yp_token_t *operator) { static yp_multi_write_node_t *
node->operator_loc = YP_OPTIONAL_LOCATION_TOKEN_VALUE(operator); yp_multi_write_node_create(yp_parser_t *parser, yp_multi_target_node_t *target, const yp_token_t *operator, yp_node_t *value) {
yp_multi_write_node_t *node = YP_ALLOC_NODE(parser, yp_multi_write_node_t);
*node = (yp_multi_write_node_t) {
{
.type = YP_MULTI_WRITE_NODE,
.location = {
.start = target->base.location.start,
.end = value->location.end
}
},
.target = target,
.operator_loc = YP_LOCATION_TOKEN_VALUE(operator),
.value = value
};
return node;
} }
// Allocate and initialize a new NextNode node. // Allocate and initialize a new NextNode node.
@ -8080,7 +8091,7 @@ parse_target(yp_parser_t *parser, yp_node_t *target) {
assert(sizeof(yp_instance_variable_target_node_t) == sizeof(yp_instance_variable_read_node_t)); assert(sizeof(yp_instance_variable_target_node_t) == sizeof(yp_instance_variable_read_node_t));
target->type = YP_INSTANCE_VARIABLE_TARGET_NODE; target->type = YP_INSTANCE_VARIABLE_TARGET_NODE;
return target; return target;
case YP_MULTI_WRITE_NODE: case YP_MULTI_TARGET_NODE:
return target; return target;
case YP_SPLAT_NODE: { case YP_SPLAT_NODE: {
yp_splat_node_t *splat = (yp_splat_node_t *) target; yp_splat_node_t *splat = (yp_splat_node_t *) target;
@ -8089,13 +8100,10 @@ parse_target(yp_parser_t *parser, yp_node_t *target) {
splat->expression = parse_target(parser, splat->expression); splat->expression = parse_target(parser, splat->expression);
} }
yp_token_t operator = not_provided(parser); yp_multi_target_node_t *multi_target = yp_multi_target_node_create(parser);
yp_location_t location = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE; yp_multi_target_node_targets_append(multi_target, (yp_node_t *) splat);
yp_multi_write_node_t *multi_write = yp_multi_write_node_create(parser, &operator, NULL, &location, &location); return (yp_node_t *) multi_target;
yp_multi_write_node_targets_append(multi_write, (yp_node_t *) splat);
return (yp_node_t *) multi_write;
} }
case YP_CALL_NODE: { case YP_CALL_NODE: {
yp_call_node_t *call = (yp_call_node_t *) target; yp_call_node_t *call = (yp_call_node_t *) target;
@ -8221,14 +8229,8 @@ parse_write(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_nod
yp_node_destroy(parser, target); yp_node_destroy(parser, target);
return write_node; return write_node;
} }
case YP_MULTI_WRITE_NODE: { case YP_MULTI_TARGET_NODE:
yp_multi_write_node_t *multi_write = (yp_multi_write_node_t *) target; return (yp_node_t *) yp_multi_write_node_create(parser, (yp_multi_target_node_t *) target, operator, value);
yp_multi_write_node_operator_loc_set(multi_write, operator);
multi_write->value = value;
multi_write->base.location.end = value->location.end;
return (yp_node_t *) multi_write;
}
case YP_SPLAT_NODE: { case YP_SPLAT_NODE: {
yp_splat_node_t *splat = (yp_splat_node_t *) target; yp_splat_node_t *splat = (yp_splat_node_t *) target;
@ -8236,11 +8238,10 @@ parse_write(yp_parser_t *parser, yp_node_t *target, yp_token_t *operator, yp_nod
splat->expression = parse_write(parser, splat->expression, operator, value); splat->expression = parse_write(parser, splat->expression, operator, value);
} }
yp_location_t location = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE; yp_multi_target_node_t *multi_target = yp_multi_target_node_create(parser);
yp_multi_write_node_t *multi_write = yp_multi_write_node_create(parser, operator, value, &location, &location); yp_multi_target_node_targets_append(multi_target, (yp_node_t *) splat);
yp_multi_write_node_targets_append(multi_write, (yp_node_t *) splat);
return (yp_node_t *) multi_write; return (yp_node_t *) yp_multi_write_node_create(parser, multi_target, operator, value);
} }
case YP_CALL_NODE: { case YP_CALL_NODE: {
yp_call_node_t *call = (yp_call_node_t *) target; yp_call_node_t *call = (yp_call_node_t *) target;
@ -8371,11 +8372,9 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
} }
} }
yp_location_t lparen_loc = YP_OPTIONAL_LOCATION_NOT_PROVIDED_VALUE; yp_multi_target_node_t *result = yp_multi_target_node_create(parser);
yp_multi_write_node_t *result = yp_multi_write_node_create(parser, &operator, NULL, &lparen_loc, &lparen_loc);
if (first_target != NULL) { if (first_target != NULL) {
yp_multi_write_node_targets_append(result, first_target); yp_multi_target_node_targets_append(result, first_target);
} }
bool has_splat = false; bool has_splat = false;
@ -8400,7 +8399,7 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
} }
yp_node_t *splat = (yp_node_t *) yp_splat_node_create(parser, &star_operator, name); yp_node_t *splat = (yp_node_t *) yp_splat_node_create(parser, &star_operator, name);
yp_multi_write_node_targets_append(result, splat); yp_multi_target_node_targets_append(result, splat);
has_splat = true; has_splat = true;
} else if (accept(parser, YP_TOKEN_PARENTHESIS_LEFT)) { } else if (accept(parser, YP_TOKEN_PARENTHESIS_LEFT)) {
// Here we have a parenthesized list of targets. We'll recurse down into // Here we have a parenthesized list of targets. We'll recurse down into
@ -8414,39 +8413,29 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
expect(parser, YP_TOKEN_PARENTHESIS_RIGHT, YP_ERR_EXPECT_RPAREN_AFTER_MULTI); expect(parser, YP_TOKEN_PARENTHESIS_RIGHT, YP_ERR_EXPECT_RPAREN_AFTER_MULTI);
yp_token_t rparen = parser->previous; yp_token_t rparen = parser->previous;
if (YP_NODE_TYPE_P(child_target, YP_MULTI_WRITE_NODE) && first_target == NULL && result->targets.size == 0) { if (YP_NODE_TYPE_P(child_target, YP_MULTI_TARGET_NODE) && first_target == NULL && result->targets.size == 0) {
yp_node_destroy(parser, (yp_node_t *) result); yp_node_destroy(parser, (yp_node_t *) result);
result = (yp_multi_write_node_t *) child_target; result = (yp_multi_target_node_t *) child_target;
result->base.location.start = lparen.start; result->base.location.start = lparen.start;
result->base.location.end = rparen.end; result->base.location.end = rparen.end;
result->lparen_loc = YP_LOCATION_TOKEN_VALUE(&lparen); result->lparen_loc = YP_LOCATION_TOKEN_VALUE(&lparen);
result->rparen_loc = YP_LOCATION_TOKEN_VALUE(&rparen); result->rparen_loc = YP_LOCATION_TOKEN_VALUE(&rparen);
} else { } else {
yp_multi_write_node_t *target; yp_multi_target_node_t *target;
if (YP_NODE_TYPE_P(child_target, YP_MULTI_WRITE_NODE)) { if (YP_NODE_TYPE_P(child_target, YP_MULTI_TARGET_NODE)) {
target = (yp_multi_write_node_t *) child_target; target = (yp_multi_target_node_t *) child_target;
target->base.location.start = lparen.start;
target->base.location.end = rparen.end;
target->lparen_loc = YP_LOCATION_TOKEN_VALUE(&lparen);
target->rparen_loc = YP_LOCATION_TOKEN_VALUE(&rparen);
} else { } else {
yp_token_t operator = not_provided(parser); target = yp_multi_target_node_create(parser);
yp_multi_target_node_targets_append(target, child_target);
target = yp_multi_write_node_create(
parser,
&operator,
NULL,
&YP_LOCATION_TOKEN_VALUE(&lparen),
&YP_LOCATION_TOKEN_VALUE(&rparen)
);
yp_multi_write_node_targets_append(target, child_target);
} }
target->base.location.start = lparen.start; target->base.location.start = lparen.start;
target->base.location.end = rparen.end; target->base.location.end = rparen.end;
yp_multi_write_node_targets_append(result, (yp_node_t *) target); target->lparen_loc = YP_LOCATION_TOKEN_VALUE(&lparen);
target->rparen_loc = YP_LOCATION_TOKEN_VALUE(&rparen);
yp_multi_target_node_targets_append(result, (yp_node_t *) target);
} }
} else { } else {
if (!token_begins_expression_p(parser->current.type) && !match_type_p(parser, YP_TOKEN_USTAR)) { if (!token_begins_expression_p(parser->current.type) && !match_type_p(parser, YP_TOKEN_USTAR)) {
@ -8462,14 +8451,14 @@ parse_targets(yp_parser_t *parser, yp_node_t *first_target, yp_binding_power_t b
// We need to indicate this somehow in the tree, so we'll add an // We need to indicate this somehow in the tree, so we'll add an
// anonymous splat. // anonymous splat.
yp_node_t *splat = (yp_node_t *) yp_splat_node_create(parser, &parser->previous, NULL); yp_node_t *splat = (yp_node_t *) yp_splat_node_create(parser, &parser->previous, NULL);
yp_multi_write_node_targets_append(result, splat); yp_multi_target_node_targets_append(result, splat);
return (yp_node_t *) result; return (yp_node_t *) result;
} }
yp_node_t *target = parse_expression(parser, binding_power, YP_ERR_EXPECT_EXPRESSION_AFTER_COMMA); yp_node_t *target = parse_expression(parser, binding_power, YP_ERR_EXPECT_EXPRESSION_AFTER_COMMA);
target = parse_target(parser, target); target = parse_target(parser, target);
yp_multi_write_node_targets_append(result, target); yp_multi_target_node_targets_append(result, target);
} }
} while (accept(parser, YP_TOKEN_COMMA)); } while (accept(parser, YP_TOKEN_COMMA));
} }
@ -9681,7 +9670,7 @@ parse_conditional(yp_parser_t *parser, yp_context_t context) {
// can be transformed into write targets. // can be transformed into write targets.
#define YP_CASE_WRITABLE YP_CLASS_VARIABLE_READ_NODE: case YP_CONSTANT_PATH_NODE: \ #define YP_CASE_WRITABLE YP_CLASS_VARIABLE_READ_NODE: case YP_CONSTANT_PATH_NODE: \
case YP_CONSTANT_READ_NODE: case YP_GLOBAL_VARIABLE_READ_NODE: case YP_LOCAL_VARIABLE_READ_NODE: \ case YP_CONSTANT_READ_NODE: case YP_GLOBAL_VARIABLE_READ_NODE: case YP_LOCAL_VARIABLE_READ_NODE: \
case YP_INSTANCE_VARIABLE_READ_NODE: case YP_MULTI_WRITE_NODE: case YP_BACK_REFERENCE_READ_NODE: \ case YP_INSTANCE_VARIABLE_READ_NODE: case YP_MULTI_TARGET_NODE: case YP_BACK_REFERENCE_READ_NODE: \
case YP_NUMBERED_REFERENCE_READ_NODE case YP_NUMBERED_REFERENCE_READ_NODE
// Parse a node that is part of a string. If the subsequent tokens cannot be // Parse a node that is part of a string. If the subsequent tokens cannot be
@ -10956,29 +10945,27 @@ parse_expression_prefix(yp_parser_t *parser, yp_binding_power_t binding_power) {
yp_accepts_block_stack_pop(parser); yp_accepts_block_stack_pop(parser);
// If we have a single statement and are ending on a right parenthesis, // If we have a single statement and are ending on a right parenthesis,
// then we need to check if this is possibly a multiple assignment node. // then we need to check if this is possibly a multiple target node.
if (binding_power == YP_BINDING_POWER_STATEMENT && YP_NODE_TYPE_P(statement, YP_MULTI_WRITE_NODE)) { if (binding_power == YP_BINDING_POWER_STATEMENT && YP_NODE_TYPE_P(statement, YP_MULTI_TARGET_NODE)) {
yp_multi_write_node_t *multi_statement = (yp_multi_write_node_t *) statement; yp_node_t *target;
yp_multi_target_node_t *multi_target = (yp_multi_target_node_t *) statement;
if (multi_statement->value == NULL) { yp_location_t lparen_loc = YP_LOCATION_TOKEN_VALUE(&opening);
yp_location_t lparen_loc = YP_LOCATION_TOKEN_VALUE(&opening); yp_location_t rparen_loc = YP_LOCATION_TOKEN_VALUE(&parser->previous);
yp_location_t rparen_loc = YP_LOCATION_TOKEN_VALUE(&parser->previous);
yp_multi_write_node_t *multi_write;
if (multi_statement->lparen_loc.start == NULL) { if (multi_target->lparen_loc.start == NULL) {
multi_write = (yp_multi_write_node_t *) statement; multi_target->base.location.start = lparen_loc.start;
multi_write->base.location.start = lparen_loc.start; multi_target->base.location.end = rparen_loc.end;
multi_write->base.location.end = rparen_loc.end; multi_target->lparen_loc = lparen_loc;
multi_write->lparen_loc = lparen_loc; multi_target->rparen_loc = rparen_loc;
multi_write->rparen_loc = rparen_loc; target = (yp_node_t *) multi_target;
} else { } else {
yp_token_t operator = not_provided(parser); yp_multi_target_node_t *parent_target = yp_multi_target_node_create(parser);
multi_write = yp_multi_write_node_create(parser, &operator, NULL, &lparen_loc, &rparen_loc); yp_multi_target_node_targets_append(parent_target, (yp_node_t *) multi_target);
yp_multi_write_node_targets_append(multi_write, statement); target = (yp_node_t *) parent_target;
}
return parse_targets(parser, (yp_node_t *) multi_write, YP_BINDING_POWER_INDEX);
} }
return parse_targets(parser, target, YP_BINDING_POWER_INDEX);
} }
// If we have a single statement and are ending on a right parenthesis // If we have a single statement and are ending on a right parenthesis