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

[ruby/yarp] Provide target node versions

Browse Source 
https://github.com/ruby/yarp/commit/a026564d38
This commit is contained in:
Kevin Newton 2023-08-25 11:57:37 -04:00 committed by git
parent aeef709109
commit 7898b8e1ea
49 changed files with 340 additions and 323 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
test/yarp/location_test.rb
View File

@ -215,6 +215,12 @@ module YARP
assert_location(ClassVariableReadNode, "@@foo")
end
def test_ClassVariableTargetNode
assert_location(ClassVariableTargetNode, "@@foo, @@bar = baz", 0...5) do |node|
node.targets.first
end
end
def test_ClassVariableWriteNode
assert_location(ClassVariableWriteNode, "@@foo = bar")
end
@ -232,11 +238,17 @@ module YARP
def test_ConstantPathOperatorWriteNode
assert_location(ConstantPathOperatorWriteNode, "Parent::Child += bar")
end
def test_ConstantPathOrWriteNode
assert_location(ConstantPathOrWriteNode, "Parent::Child ||= bar")
end
def test_ConstantPathTargetNode
assert_location(ConstantPathTargetNode, "::Foo, ::Bar = baz", 0...5) do |node|
node.targets.first
end
end
def test_ConstantPathWriteNode
assert_location(ConstantPathWriteNode, "Foo::Bar = baz")
assert_location(ConstantPathWriteNode, "::Foo = bar")
@ -246,11 +258,11 @@ module YARP
def test_ConstantAndWriteNode
assert_location(ConstantAndWriteNode, "Foo &&= bar")
end
def test_ConstantOperatorWriteNode
assert_location(ConstantOperatorWriteNode, "Foo += bar")
end
def test_ConstantOrWriteNode
assert_location(ConstantOrWriteNode, "Foo ||= bar")
end
@ -260,6 +272,16 @@ module YARP
assert_location(ConstantReadNode, "Foo::Bar", 5...8, &:child)
end
def test_ConstantTargetNode
assert_location(ConstantTargetNode, "Foo, Bar = baz", 0...3) do |node|
node.targets.first
end
end
def test_ConstantWriteNode
assert_location(ConstantWriteNode, "Foo = bar")
end
def test_DefNode
assert_location(DefNode, "def foo; bar; end")
assert_location(DefNode, "def foo = bar")
@ -299,6 +321,10 @@ module YARP
end
end
def test_FlipFlopNode
assert_location(FlipFlopNode, "if foo..bar; end", 3..11, &:predicate)
end
def test_FloatNode
assert_location(FloatNode, "0.0")
assert_location(FloatNode, "1.0")
@ -331,11 +357,11 @@ module YARP
def test_GlobalVariableAndWriteNode
assert_location(GlobalVariableAndWriteNode, "$foo &&= bar")
end
def test_GlobalVariableOperatorWriteNode
assert_location(GlobalVariableOperatorWriteNode, "$foo += bar")
end
def test_GlobalVariableOrWriteNode
assert_location(GlobalVariableOrWriteNode, "$foo ||= bar")
end
@ -344,6 +370,12 @@ module YARP
assert_location(GlobalVariableReadNode, "$foo")
end
def test_GlobalVariableTargetNode
assert_location(GlobalVariableTargetNode, "$foo, $bar = baz", 0...4) do |node|
node.targets.first
end
end
def test_GlobalVariableWriteNode
assert_location(GlobalVariableWriteNode, "$foo = bar")
end
@ -377,11 +409,11 @@ module YARP
def test_InstanceVariableAndWriteNode
assert_location(InstanceVariableAndWriteNode, "@foo &&= bar")
end
def test_InstanceVariableOperatorWriteNode
assert_location(InstanceVariableOperatorWriteNode, "@foo += bar")
end
def test_InstanceVariableOrWriteNode
assert_location(InstanceVariableOrWriteNode, "@foo ||= bar")
end
@ -390,6 +422,12 @@ module YARP
assert_location(InstanceVariableReadNode, "@foo")
end
def test_InstanceVariableTargetNode
assert_location(InstanceVariableTargetNode, "@foo, @bar = baz", 0...4) do |node|
node.targets.first
end
end
def test_InstanceVariableWriteNode
assert_location(InstanceVariableWriteNode, "@foo = bar")
end
@ -456,12 +494,12 @@ module YARP
assert_location(LocalVariableAndWriteNode, "foo &&= bar")
assert_location(LocalVariableAndWriteNode, "foo = 1; foo &&= bar", 9...20)
end
def test_LocalVariableOperatorWriteNode
assert_location(LocalVariableOperatorWriteNode, "foo += bar")
assert_location(LocalVariableOperatorWriteNode, "foo = 1; foo += bar", 9...19)
end
def test_LocalVariableOrWriteNode
assert_location(LocalVariableOrWriteNode, "foo ||= bar")
assert_location(LocalVariableOrWriteNode, "foo = 1; foo ||= bar", 9...20)
@ -471,6 +509,12 @@ module YARP
assert_location(LocalVariableReadNode, "foo = 1; foo", 9...12)
end
def test_LocalVariableTargetNode
assert_location(LocalVariableTargetNode, "foo, bar = baz", 0...3) do |node|
node.targets.first
end
end
def test_LocalVariableWriteNode
assert_location(LocalVariableWriteNode, "foo = bar")
end
@ -751,6 +795,12 @@ module YARP
assert_location(YieldNode, "yield(foo)")
end
def test_all_tested
expected = YARP.constants.grep(/.Node$/).sort - %i[MissingNode ProgramNode]
actual = LocationTest.instance_methods(false).grep(/.Node$/).map { |name| name[5..].to_sym }.sort
assert_equal expected, actual
end
private
def assert_location(kind, source, expected = 0...source.length)

10
test/yarp/snapshots/begin_rescue.txt
View File

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

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

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

2
test/yarp/snapshots/seattlerb/dasgn_icky2.txt
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

20
test/yarp/snapshots/unparser/corpus/literal/block.txt
View File

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

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

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

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

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

14
test/yarp/snapshots/unparser/corpus/literal/kwbegin.txt
View File

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2
test/yarp/snapshots/whitequark/resbody_list_var.txt
View File

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

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

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

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

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

48
yarp/config.yml
View File

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

101
yarp/yarp.c
View File

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