From a38ca45b6570ab378890664c9e8683f0c16cdd78 Mon Sep 17 00:00:00 2001 From: Kevin Newton Date: Fri, 25 Aug 2023 10:49:00 -0400 Subject: [PATCH] [ruby/yarp] Split up AndWriteNode, OrWriteNode, OperatorWriteNode https://github.com/ruby/yarp/commit/6d3b3b5776 --- test/yarp/location_test.rb | 105 ++- test/yarp/snapshots/blocks.txt | 8 +- test/yarp/snapshots/boolean_operators.txt | 24 +- test/yarp/snapshots/defined.txt | 8 +- .../seattlerb/bug_op_asgn_rescue.txt | 8 +- .../seattlerb/const_2_op_asgn_or2.txt | 18 +- .../seattlerb/const_3_op_asgn_or.txt | 12 +- .../seattlerb/const_op_asgn_and1.txt | 12 +- .../seattlerb/const_op_asgn_and2.txt | 12 +- .../snapshots/seattlerb/const_op_asgn_or.txt | 18 +- .../seattlerb/messy_op_asgn_lineno.txt | 18 +- .../seattlerb/op_asgn_command_call.txt | 8 +- ..._asgn_primary_colon_const_command_call.txt | 18 +- .../seattlerb/parse_line_defn_complex.txt | 8 +- .../seattlerb/parse_line_op_asgn.txt | 8 +- .../unparser/corpus/literal/assignment.txt | 16 +- .../unparser/corpus/literal/opasgn.txt | 72 +- .../unparser/corpus/literal/send.txt | 8 +- .../snapshots/whitequark/const_op_asgn.txt | 72 +- .../yarp/snapshots/whitequark/op_asgn_cmd.txt | 28 +- .../whitequark/rescue_mod_op_assign.txt | 10 +- .../snapshots/whitequark/ruby_bug_12402.txt | 58 +- .../snapshots/whitequark/ruby_bug_12669.txt | 42 +- .../snapshots/whitequark/var_and_asgn.txt | 8 +- .../yarp/snapshots/whitequark/var_op_asgn.txt | 32 +- .../snapshots/whitequark/var_op_asgn_cmd.txt | 10 +- .../yarp/snapshots/whitequark/var_or_asgn.txt | 8 +- yarp/config.yml | 302 ++++++-- yarp/yarp.c | 683 +++++++++++++++--- 29 files changed, 1177 insertions(+), 457 deletions(-) diff --git a/test/yarp/location_test.rb b/test/yarp/location_test.rb index 703c8e24f0..c7f9c0091b 100644 --- a/test/yarp/location_test.rb +++ b/test/yarp/location_test.rb @@ -17,16 +17,6 @@ module YARP assert_location(AndNode, "foo && bar") end - def test_AndWriteNode - assert_location(AndWriteNode, "foo &&= bar") - assert_location(AndWriteNode, "foo = 1; foo &&= bar", 9...20) - assert_location(AndWriteNode, "@@foo &&= bar") - assert_location(AndWriteNode, "Parent::Child &&= bar") - assert_location(AndWriteNode, "Foo &&= bar") - assert_location(AndWriteNode, "$foo &&= bar") - assert_location(AndWriteNode, "@foo &&= bar") - end - def test_ArgumentsNode assert_location(ArgumentsNode, "foo(bar, baz, qux)", 4...17, &:arguments) end @@ -209,6 +199,18 @@ module YARP assert_location(ClassNode, "class Foo < Bar end") end + def test_ClassVariableAndWriteNode + assert_location(ClassVariableAndWriteNode, "@@foo &&= bar") + end + + def test_ClassVariableOperatorWriteNode + assert_location(ClassVariableOperatorWriteNode, "@@foo += bar") + end + + def test_ClassVariableOrWriteNode + assert_location(ClassVariableOrWriteNode, "@@foo ||= bar") + end + def test_ClassVariableReadNode assert_location(ClassVariableReadNode, "@@foo") end @@ -217,18 +219,42 @@ module YARP assert_location(ClassVariableWriteNode, "@@foo = bar") end + def test_ConstantPathAndWriteNode + assert_location(ConstantPathAndWriteNode, "Parent::Child &&= bar") + end + def test_ConstantPathNode assert_location(ConstantPathNode, "Foo::Bar") assert_location(ConstantPathNode, "::Foo") assert_location(ConstantPathNode, "::Foo::Bar") end + def test_ConstantPathOperatorWriteNode + assert_location(ConstantPathOperatorWriteNode, "Parent::Child += bar") + end + + def test_ConstantPathOrWriteNode + assert_location(ConstantPathOrWriteNode, "Parent::Child ||= bar") + end + def test_ConstantPathWriteNode assert_location(ConstantPathWriteNode, "Foo::Bar = baz") assert_location(ConstantPathWriteNode, "::Foo = bar") assert_location(ConstantPathWriteNode, "::Foo::Bar = baz") end + 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 + def test_ConstantReadNode assert_location(ConstantReadNode, "Foo") assert_location(ConstantReadNode, "Foo::Bar", 5...8, &:child) @@ -302,6 +328,18 @@ module YARP assert_location(ForwardingSuperNode, "super {}") end + 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 + def test_GlobalVariableReadNode assert_location(GlobalVariableReadNode, "$foo") end @@ -336,6 +374,18 @@ module YARP end end + 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 + def test_InstanceVariableReadNode assert_location(InstanceVariableReadNode, "@foo") end @@ -402,6 +452,21 @@ module YARP assert_location(LambdaNode, "-> do foo end") end + def test_LocalVariableAndWriteNode + 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) + end + def test_LocalVariableReadNode assert_location(LocalVariableReadNode, "foo = 1; foo", 9...12) end @@ -445,16 +510,6 @@ module YARP assert_location(NumberedReferenceReadNode, "$1") end - def test_OperatorWriteNode - assert_location(OperatorWriteNode, "@@foo += bar") - assert_location(OperatorWriteNode, "Parent::Child += bar") - assert_location(OperatorWriteNode, "Foo += bar") - assert_location(OperatorWriteNode, "$foo += bar") - assert_location(OperatorWriteNode, "@foo += bar") - assert_location(OperatorWriteNode, "foo += bar") - assert_location(OperatorWriteNode, "foo = 1; foo += bar", 9...19) - end - def test_OptionalParameterNode assert_location(OptionalParameterNode, "def foo(bar = nil); end", 8...17) do |node| node.parameters.optionals.first @@ -466,16 +521,6 @@ module YARP assert_location(OrNode, "foo or bar") end - def test_OrWriteNode - assert_location(OrWriteNode, "@@foo ||= bar") - assert_location(OrWriteNode, "Parent::Child ||= bar") - assert_location(OrWriteNode, "Foo ||= bar") - assert_location(OrWriteNode, "$foo ||= bar") - assert_location(OrWriteNode, "@foo ||= bar") - assert_location(OrWriteNode, "foo ||= bar") - assert_location(OrWriteNode, "foo = 1; foo ||= bar", 9...20) - end - def test_ParametersNode assert_location(ParametersNode, "def foo(bar, baz); end", 8...16, &:parameters) end diff --git a/test/yarp/snapshots/blocks.txt b/test/yarp/snapshots/blocks.txt index 089b63b89c..8f836208ca 100644 --- a/test/yarp/snapshots/blocks.txt +++ b/test/yarp/snapshots/blocks.txt @@ -88,11 +88,13 @@ ProgramNode(0...402)( (61...62) ), StatementsNode(63...72)( - [OperatorWriteNode(63...72)( - LocalVariableWriteNode(63...67)(:memo, 0, nil, (63...67), nil), + [LocalVariableOperatorWriteNode(63...72)( + (63...67), (68...70), + LocalVariableReadNode(71...72)(:x, 0), + :memo, :+, - LocalVariableReadNode(71...72)(:x, 0) + 0 )] ), (51...52), diff --git a/test/yarp/snapshots/boolean_operators.txt b/test/yarp/snapshots/boolean_operators.txt index c6cfc311e5..f1fc5cd4b2 100644 --- a/test/yarp/snapshots/boolean_operators.txt +++ b/test/yarp/snapshots/boolean_operators.txt @@ -1,21 +1,27 @@ ProgramNode(0...24)( [:a], StatementsNode(0...24)( - [AndWriteNode(0...7)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableAndWriteNode(0...7)( + (0...1), + (2...5), CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"), - (2...5) + :a, + 0 ), - OperatorWriteNode(9...15)( - LocalVariableWriteNode(9...10)(:a, 0, nil, (9...10), nil), + LocalVariableOperatorWriteNode(9...15)( + (9...10), (11...13), + CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "b"), + :a, :+, - CallNode(14...15)(nil, nil, (14...15), nil, nil, nil, nil, 2, "b") + 0 ), - OrWriteNode(17...24)( - LocalVariableWriteNode(17...18)(:a, 0, nil, (17...18), nil), + LocalVariableOrWriteNode(17...24)( + (17...18), + (19...22), CallNode(23...24)(nil, nil, (23...24), nil, nil, nil, nil, 2, "b"), - (19...22) + :a, + 0 )] ) ) diff --git a/test/yarp/snapshots/defined.txt b/test/yarp/snapshots/defined.txt index 6c2cad656e..1d4b5a5502 100644 --- a/test/yarp/snapshots/defined.txt +++ b/test/yarp/snapshots/defined.txt @@ -8,11 +8,13 @@ ProgramNode(0...78)( ), DefinedNode(27...43)( (35...36), - OperatorWriteNode(36...42)( - LocalVariableWriteNode(36...37)(:x, 0, nil, (36...37), nil), + LocalVariableOperatorWriteNode(36...42)( + (36...37), (38...40), + IntegerNode(41...42)(), + :x, :%, - IntegerNode(41...42)() + 0 ), (42...43), (27...35) diff --git a/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt b/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt index c672ef6b79..2bd4f430e3 100644 --- a/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt +++ b/test/yarp/snapshots/seattlerb/bug_op_asgn_rescue.txt @@ -1,14 +1,16 @@ ProgramNode(0...18)( [:a], StatementsNode(0...18)( - [OrWriteNode(0...18)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableOrWriteNode(0...18)( + (0...1), + (2...5), RescueModifierNode(6...18)( CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"), (8...14), NilNode(15...18)() ), - (2...5) + :a, + 0 )] ) ) diff --git a/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt b/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt index 7405ad8e5d..48a4d61f52 100644 --- a/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt +++ b/test/yarp/snapshots/seattlerb/const_2_op_asgn_or2.txt @@ -1,18 +1,14 @@ ProgramNode(0...12)( [], StatementsNode(0...12)( - [OrWriteNode(0...12)( - ConstantPathWriteNode(0...6)( - ConstantPathNode(0...6)( - ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), - ConstantReadNode(5...6)(), - (3...5) - ), - nil, - nil + [ConstantPathOrWriteNode(0...12)( + ConstantPathNode(0...6)( + ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), + ConstantReadNode(5...6)(), + (3...5) ), - IntegerNode(11...12)(), - (7...10) + (7...10), + IntegerNode(11...12)() )] ) ) diff --git a/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt b/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt index 838287c59f..327e0a9643 100644 --- a/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt +++ b/test/yarp/snapshots/seattlerb/const_3_op_asgn_or.txt @@ -1,14 +1,10 @@ ProgramNode(0...9)( [], StatementsNode(0...9)( - [OrWriteNode(0...9)( - ConstantPathWriteNode(0...3)( - ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), - nil, - nil - ), - IntegerNode(8...9)(), - (4...7) + [ConstantPathOrWriteNode(0...9)( + ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), + (4...7), + IntegerNode(8...9)() )] ) ) diff --git a/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt b/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt index 2fdcd97205..1e7dce0226 100644 --- a/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt +++ b/test/yarp/snapshots/seattlerb/const_op_asgn_and1.txt @@ -1,15 +1,11 @@ ProgramNode(0...8)( [], StatementsNode(0...8)( - [OperatorWriteNode(0...8)( - ConstantPathWriteNode(0...3)( - ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), - nil, - nil - ), + [ConstantPathOperatorWriteNode(0...8)( + ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), (4...6), - :&, - IntegerNode(7...8)() + IntegerNode(7...8)(), + :& )] ) ) diff --git a/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt b/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt index 275aa8238d..8c9d3ac353 100644 --- a/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt +++ b/test/yarp/snapshots/seattlerb/const_op_asgn_and2.txt @@ -1,14 +1,10 @@ ProgramNode(0...9)( [], StatementsNode(0...9)( - [AndWriteNode(0...9)( - ConstantPathWriteNode(0...3)( - ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), - nil, - nil - ), - IntegerNode(8...9)(), - (4...7) + [ConstantPathAndWriteNode(0...9)( + ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), + (4...7), + IntegerNode(8...9)() )] ) ) diff --git a/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt b/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt index c14175c4e3..d812fe5a55 100644 --- a/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt +++ b/test/yarp/snapshots/seattlerb/const_op_asgn_or.txt @@ -1,18 +1,14 @@ ProgramNode(0...10)( [], StatementsNode(0...10)( - [OrWriteNode(0...10)( - ConstantPathWriteNode(0...4)( - ConstantPathNode(0...4)( - ConstantReadNode(0...1)(), - ConstantReadNode(3...4)(), - (1...3) - ), - nil, - nil + [ConstantPathOrWriteNode(0...10)( + ConstantPathNode(0...4)( + ConstantReadNode(0...1)(), + ConstantReadNode(3...4)(), + (1...3) ), - IntegerNode(9...10)(), - (5...8) + (5...8), + IntegerNode(9...10)() )] ) ) diff --git a/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt b/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt index 8c678e890d..71a28870bd 100644 --- a/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt +++ b/test/yarp/snapshots/seattlerb/messy_op_asgn_lineno.txt @@ -9,18 +9,13 @@ ProgramNode(0...15)( ArgumentsNode(2...15)( [ParenthesesNode(2...15)( StatementsNode(3...14)( - [OperatorWriteNode(3...14)( - ConstantPathWriteNode(3...7)( - ConstantPathNode(3...7)( - ConstantReadNode(3...4)(), - ConstantReadNode(6...7)(), - (4...6) - ), - nil, - nil + [ConstantPathOperatorWriteNode(3...14)( + ConstantPathNode(3...7)( + ConstantReadNode(3...4)(), + ConstantReadNode(6...7)(), + (4...6) ), (8...10), - :*, CallNode(11...14)( nil, nil, @@ -43,7 +38,8 @@ ProgramNode(0...15)( nil, 0, "d" - ) + ), + :* )] ), (2...3), diff --git a/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt index deb7e17066..cf092dd5de 100644 --- a/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt +++ b/test/yarp/snapshots/seattlerb/op_asgn_command_call.txt @@ -1,8 +1,9 @@ ProgramNode(0...11)( [:a], StatementsNode(0...11)( - [OrWriteNode(0...11)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableOrWriteNode(0...11)( + (0...1), + (2...5), CallNode(6...11)( CallNode(6...7)(nil, nil, (6...7), nil, nil, nil, nil, 2, "b"), (7...8), @@ -14,7 +15,8 @@ ProgramNode(0...11)( 0, "c" ), - (2...5) + :a, + 0 )] ) ) diff --git a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt index d071a45442..0cd3775202 100644 --- a/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt +++ b/test/yarp/snapshots/seattlerb/op_asgn_primary_colon_const_command_call.txt @@ -1,18 +1,13 @@ ProgramNode(0...11)( [], StatementsNode(0...11)( - [OperatorWriteNode(0...11)( - ConstantPathWriteNode(0...4)( - ConstantPathNode(0...4)( - ConstantReadNode(0...1)(), - ConstantReadNode(3...4)(), - (1...3) - ), - nil, - nil + [ConstantPathOperatorWriteNode(0...11)( + ConstantPathNode(0...4)( + ConstantReadNode(0...1)(), + ConstantReadNode(3...4)(), + (1...3) ), (5...7), - :*, CallNode(8...11)( nil, nil, @@ -25,7 +20,8 @@ ProgramNode(0...11)( nil, 0, "c" - ) + ), + :* )] ) ) diff --git a/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt b/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt index 5d4820bef3..170b9bc81e 100644 --- a/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt +++ b/test/yarp/snapshots/seattlerb/parse_line_defn_complex.txt @@ -25,11 +25,13 @@ ProgramNode(0...40)( 0, "p" ), - OperatorWriteNode(18...24)( - LocalVariableWriteNode(18...19)(:y, 0, nil, (18...19), nil), + LocalVariableOperatorWriteNode(18...24)( + (18...19), (20...22), + IntegerNode(23...24)(), + :y, :*, - IntegerNode(23...24)() + 0 ), ReturnNode(27...35)( (27...33), diff --git a/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt b/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt index d8bd989184..d3aa84c986 100644 --- a/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt +++ b/test/yarp/snapshots/seattlerb/parse_line_op_asgn.txt @@ -1,11 +1,13 @@ ProgramNode(6...34)( [:foo], StatementsNode(6...34)( - [OperatorWriteNode(6...24)( - LocalVariableWriteNode(6...9)(:foo, 0, nil, (6...9), nil), + [LocalVariableOperatorWriteNode(6...24)( + (6...9), (10...12), + CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "bar"), + :foo, :+, - CallNode(21...24)(nil, nil, (21...24), nil, nil, nil, nil, 2, "bar") + 0 ), CallNode(31...34)(nil, nil, (31...34), nil, nil, nil, nil, 2, "baz")] ) diff --git a/test/yarp/snapshots/unparser/corpus/literal/assignment.txt b/test/yarp/snapshots/unparser/corpus/literal/assignment.txt index ffaedf4f18..71f7e8974b 100644 --- a/test/yarp/snapshots/unparser/corpus/literal/assignment.txt +++ b/test/yarp/snapshots/unparser/corpus/literal/assignment.txt @@ -610,10 +610,10 @@ ProgramNode(0...704)( ), (543...546) ), - OrWriteNode(551...561)( - InstanceVariableWriteNode(551...553)((551...553), nil, nil), - StringNode(558...561)((558...560), (560...560), (560...561), ""), - (554...557) + InstanceVariableOrWriteNode(551...561)( + (551...553), + (554...557), + StringNode(558...561)((558...560), (560...560), (560...561), "") ), LocalVariableWriteNode(562...576)( :x, @@ -703,16 +703,16 @@ ProgramNode(0...704)( ), (665...668) ), - OrWriteNode(687...704)( - InstanceVariableWriteNode(687...689)((687...689), nil, nil), + InstanceVariableOrWriteNode(687...704)( + (687...689), + (690...693), InterpolatedStringNode(694...704)( (694...704), [StringNode(705...707)(nil, (705...707), nil, " "), EmbeddedStatementsNode(707...710)((707...709), nil, (709...710)), StringNode(710...711)(nil, (710...711), nil, "\n")], (711...719) - ), - (690...693) + ) )] ) ) diff --git a/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt b/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt index 9804597663..15d621cbf6 100644 --- a/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt +++ b/test/yarp/snapshots/unparser/corpus/literal/opasgn.txt @@ -1,53 +1,69 @@ ProgramNode(0...233)( [:a, :h], StatementsNode(0...233)( - [OperatorWriteNode(0...6)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableOperatorWriteNode(0...6)( + (0...1), (2...4), + IntegerNode(5...6)(), + :a, :+, - IntegerNode(5...6)() + 0 ), - OperatorWriteNode(7...13)( - LocalVariableWriteNode(7...8)(:a, 0, nil, (7...8), nil), + LocalVariableOperatorWriteNode(7...13)( + (7...8), (9...11), + IntegerNode(12...13)(), + :a, :-, - IntegerNode(12...13)() + 0 ), - OperatorWriteNode(14...21)( - LocalVariableWriteNode(14...15)(:a, 0, nil, (14...15), nil), + LocalVariableOperatorWriteNode(14...21)( + (14...15), (16...19), + IntegerNode(20...21)(), + :a, :**, - IntegerNode(20...21)() + 0 ), - OperatorWriteNode(22...28)( - LocalVariableWriteNode(22...23)(:a, 0, nil, (22...23), nil), + LocalVariableOperatorWriteNode(22...28)( + (22...23), (24...26), + IntegerNode(27...28)(), + :a, :*, - IntegerNode(27...28)() + 0 ), - OperatorWriteNode(29...35)( - LocalVariableWriteNode(29...30)(:a, 0, nil, (29...30), nil), + LocalVariableOperatorWriteNode(29...35)( + (29...30), (31...33), + IntegerNode(34...35)(), + :a, :/, - IntegerNode(34...35)() + 0 ), - AndWriteNode(36...43)( - LocalVariableWriteNode(36...37)(:a, 0, nil, (36...37), nil), + LocalVariableAndWriteNode(36...43)( + (36...37), + (38...41), CallNode(42...43)(nil, nil, (42...43), nil, nil, nil, nil, 2, "b"), - (38...41) + :a, + 0 ), - OrWriteNode(44...51)( - LocalVariableWriteNode(44...45)(:a, 0, nil, (44...45), nil), + LocalVariableOrWriteNode(44...51)( + (44...45), + (46...49), IntegerNode(50...51)(), - (46...49) + :a, + 0 ), CallNode(52...65)( ParenthesesNode(52...61)( StatementsNode(53...60)( - [OrWriteNode(53...60)( - LocalVariableWriteNode(53...54)(:a, 0, nil, (53...54), nil), + [LocalVariableOrWriteNode(53...60)( + (53...54), + (55...58), IntegerNode(59...60)(), - (55...58) + :a, + 0 )] ), (52...53), @@ -65,10 +81,12 @@ ProgramNode(0...233)( CallNode(66...83)( ParenthesesNode(66...76)( StatementsNode(67...75)( - [OrWriteNode(67...75)( - LocalVariableWriteNode(67...68)(:h, 0, nil, (67...68), nil), + [LocalVariableOrWriteNode(67...75)( + (67...68), + (69...72), HashNode(73...75)((73...74), [], (74...75)), - (69...72) + :h, + 0 )] ), (66...67), diff --git a/test/yarp/snapshots/unparser/corpus/literal/send.txt b/test/yarp/snapshots/unparser/corpus/literal/send.txt index 083a0140d9..4ef108e71a 100644 --- a/test/yarp/snapshots/unparser/corpus/literal/send.txt +++ b/test/yarp/snapshots/unparser/corpus/literal/send.txt @@ -6,8 +6,9 @@ ProgramNode(0...999)( (0...6), ConstantReadNode(7...8)(), StatementsNode(11...31)( - [OrWriteNode(11...31)( - LocalVariableWriteNode(11...14)(:foo, 0, nil, (11...14), nil), + [LocalVariableOrWriteNode(11...31)( + (11...14), + (15...18), ParenthesesNode(19...31)( StatementsNode(21...30)( [MultiWriteNode(21...30)( @@ -44,7 +45,8 @@ ProgramNode(0...999)( (19...20), (30...31) ), - (15...18) + :foo, + 0 )] ), (32...35), diff --git a/test/yarp/snapshots/whitequark/const_op_asgn.txt b/test/yarp/snapshots/whitequark/const_op_asgn.txt index e212170a1d..8a7bb4eae8 100644 --- a/test/yarp/snapshots/whitequark/const_op_asgn.txt +++ b/test/yarp/snapshots/whitequark/const_op_asgn.txt @@ -1,53 +1,41 @@ ProgramNode(0...77)( [], StatementsNode(0...77)( - [OperatorWriteNode(0...8)( - ConstantPathWriteNode(0...3)( - ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), - nil, - nil - ), + [ConstantPathOperatorWriteNode(0...8)( + ConstantPathNode(0...3)(nil, ConstantReadNode(2...3)(), (0...2)), (4...6), - :+, - IntegerNode(7...8)() + IntegerNode(7...8)(), + :+ ), - OperatorWriteNode(10...16)( - ConstantWriteNode(10...11)((10...11), nil, nil), + ConstantOperatorWriteNode(10...16)( + (10...11), (12...14), - :+, - IntegerNode(15...16)() + IntegerNode(15...16)(), + :+ ), - OperatorWriteNode(18...27)( - ConstantPathWriteNode(18...22)( - ConstantPathNode(18...22)( - ConstantReadNode(18...19)(), - ConstantReadNode(21...22)(), - (19...21) - ), - nil, - nil + ConstantPathOperatorWriteNode(18...27)( + ConstantPathNode(18...22)( + ConstantReadNode(18...19)(), + ConstantReadNode(21...22)(), + (19...21) ), (23...25), - :+, - IntegerNode(26...27)() + IntegerNode(26...27)(), + :+ ), DefNode(29...50)( (33...34), nil, nil, StatementsNode(36...45)( - [OrWriteNode(36...45)( - ConstantPathWriteNode(36...39)( - ConstantPathNode(36...39)( - nil, - ConstantReadNode(38...39)(), - (36...38) - ), + [ConstantPathOrWriteNode(36...45)( + ConstantPathNode(36...39)( nil, - nil + ConstantReadNode(38...39)(), + (36...38) ), - IntegerNode(44...45)(), - (40...43) + (40...43), + IntegerNode(44...45)() )] ), [], @@ -63,18 +51,14 @@ ProgramNode(0...77)( nil, nil, StatementsNode(59...72)( - [OrWriteNode(59...72)( - ConstantPathWriteNode(59...66)( - ConstantPathNode(59...66)( - SelfNode(59...63)(), - ConstantReadNode(65...66)(), - (63...65) - ), - nil, - nil + [ConstantPathOrWriteNode(59...72)( + ConstantPathNode(59...66)( + SelfNode(59...63)(), + ConstantReadNode(65...66)(), + (63...65) ), - IntegerNode(71...72)(), - (67...70) + (67...70), + IntegerNode(71...72)() )] ), [], diff --git a/test/yarp/snapshots/whitequark/op_asgn_cmd.txt b/test/yarp/snapshots/whitequark/op_asgn_cmd.txt index ccc8730d85..409aa26ee2 100644 --- a/test/yarp/snapshots/whitequark/op_asgn_cmd.txt +++ b/test/yarp/snapshots/whitequark/op_asgn_cmd.txt @@ -77,28 +77,13 @@ ProgramNode(0...64)( ), :+ ), - OperatorWriteNode(32...47)( - ConstantPathWriteNode(32...38)( - ConstantPathNode(32...38)( - CallNode(32...35)( - nil, - nil, - (32...35), - nil, - nil, - nil, - nil, - 2, - "foo" - ), - ConstantReadNode(37...38)(), - (35...37) - ), - nil, - nil + ConstantPathOperatorWriteNode(32...47)( + ConstantPathNode(32...38)( + CallNode(32...35)(nil, nil, (32...35), nil, nil, nil, nil, 2, "foo"), + ConstantReadNode(37...38)(), + (35...37) ), (39...41), - :+, CallNode(42...47)( nil, nil, @@ -121,7 +106,8 @@ ProgramNode(0...64)( nil, 0, "m" - ) + ), + :+ ), CallOperatorWriteNode(49...64)( CallNode(49...55)( diff --git a/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt b/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt index 8ae81caa8f..f9bfc7bfeb 100644 --- a/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt +++ b/test/yarp/snapshots/whitequark/rescue_mod_op_assign.txt @@ -1,15 +1,17 @@ ProgramNode(0...22)( [:foo], StatementsNode(0...22)( - [OperatorWriteNode(0...22)( - LocalVariableWriteNode(0...3)(:foo, 0, nil, (0...3), nil), + [LocalVariableOperatorWriteNode(0...22)( + (0...3), (4...6), - :+, RescueModifierNode(7...22)( CallNode(7...11)(nil, nil, (7...11), nil, nil, nil, nil, 2, "meth"), (12...18), CallNode(19...22)(nil, nil, (19...22), nil, nil, nil, nil, 2, "bar") - ) + ), + :foo, + :+, + 0 )] ) ) diff --git a/test/yarp/snapshots/whitequark/ruby_bug_12402.txt b/test/yarp/snapshots/whitequark/ruby_bug_12402.txt index 4ca03bab01..f2980c1d42 100644 --- a/test/yarp/snapshots/whitequark/ruby_bug_12402.txt +++ b/test/yarp/snapshots/whitequark/ruby_bug_12402.txt @@ -1,10 +1,9 @@ ProgramNode(0...437)( [:foo], StatementsNode(0...437)( - [OperatorWriteNode(0...27)( - LocalVariableWriteNode(0...3)(:foo, 0, nil, (0...3), nil), + [LocalVariableOperatorWriteNode(0...27)( + (0...3), (4...6), - :+, CallNode(7...27)( nil, nil, @@ -31,12 +30,14 @@ ProgramNode(0...437)( nil, 0, "raise" - ) - ), - OperatorWriteNode(29...57)( - LocalVariableWriteNode(29...32)(:foo, 0, nil, (29...32), nil), - (33...35), + ), + :foo, :+, + 0 + ), + LocalVariableOperatorWriteNode(29...57)( + (29...32), + (33...35), RescueModifierNode(36...57)( CallNode(36...46)( nil, @@ -63,7 +64,10 @@ ProgramNode(0...437)( ), (47...53), NilNode(54...57)() - ) + ), + :foo, + :+, + 0 ), LocalVariableWriteNode(59...85)( :foo, @@ -299,16 +303,13 @@ ProgramNode(0...437)( ), :+ ), - OrWriteNode(242...273)( - ConstantPathWriteNode(242...248)( - ConstantPathNode(242...248)( - LocalVariableReadNode(242...245)(:foo, 0), - ConstantReadNode(247...248)(), - (245...247) - ), - nil, - nil + ConstantPathOrWriteNode(242...273)( + ConstantPathNode(242...248)( + LocalVariableReadNode(242...245)(:foo, 0), + ConstantReadNode(247...248)(), + (245...247) ), + (249...252), CallNode(253...273)( nil, nil, @@ -335,19 +336,15 @@ ProgramNode(0...437)( nil, 0, "raise" - ), - (249...252) + ) ), - OrWriteNode(275...307)( - ConstantPathWriteNode(275...281)( - ConstantPathNode(275...281)( - LocalVariableReadNode(275...278)(:foo, 0), - ConstantReadNode(280...281)(), - (278...280) - ), - nil, - nil + ConstantPathOrWriteNode(275...307)( + ConstantPathNode(275...281)( + LocalVariableReadNode(275...278)(:foo, 0), + ConstantReadNode(280...281)(), + (278...280) ), + (282...285), RescueModifierNode(286...307)( CallNode(286...296)( nil, @@ -374,8 +371,7 @@ ProgramNode(0...437)( ), (297...303), NilNode(304...307)() - ), - (282...285) + ) ), CallOperatorWriteNode(309...339)( CallNode(309...315)( diff --git a/test/yarp/snapshots/whitequark/ruby_bug_12669.txt b/test/yarp/snapshots/whitequark/ruby_bug_12669.txt index 6eb9e9a0c8..f5ec48ce95 100644 --- a/test/yarp/snapshots/whitequark/ruby_bug_12669.txt +++ b/test/yarp/snapshots/whitequark/ruby_bug_12669.txt @@ -1,14 +1,12 @@ ProgramNode(0...74)( [:a, :b], StatementsNode(0...74)( - [OperatorWriteNode(0...18)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableOperatorWriteNode(0...18)( + (0...1), (2...4), - :+, - OperatorWriteNode(5...18)( - LocalVariableWriteNode(5...6)(:b, 0, nil, (5...6), nil), + LocalVariableOperatorWriteNode(5...18)( + (5...6), (7...9), - :+, CallNode(10...18)( nil, nil, @@ -21,13 +19,18 @@ ProgramNode(0...74)( nil, 0, "raise" - ) - ) - ), - OperatorWriteNode(20...37)( - LocalVariableWriteNode(20...21)(:a, 0, nil, (20...21), nil), - (22...24), + ), + :b, + :+, + 0 + ), + :a, :+, + 0 + ), + LocalVariableOperatorWriteNode(20...37)( + (20...21), + (22...24), LocalVariableWriteNode(25...37)( :b, 0, @@ -46,15 +49,17 @@ ProgramNode(0...74)( ), (25...26), (27...28) - ) + ), + :a, + :+, + 0 ), LocalVariableWriteNode(39...56)( :a, 0, - OperatorWriteNode(43...56)( - LocalVariableWriteNode(43...44)(:b, 0, nil, (43...44), nil), + LocalVariableOperatorWriteNode(43...56)( + (43...44), (45...47), - :+, CallNode(48...56)( nil, nil, @@ -67,7 +72,10 @@ ProgramNode(0...74)( nil, 0, "raise" - ) + ), + :b, + :+, + 0 ), (39...40), (41...42) diff --git a/test/yarp/snapshots/whitequark/var_and_asgn.txt b/test/yarp/snapshots/whitequark/var_and_asgn.txt index a082413a7d..a613761d87 100644 --- a/test/yarp/snapshots/whitequark/var_and_asgn.txt +++ b/test/yarp/snapshots/whitequark/var_and_asgn.txt @@ -1,10 +1,12 @@ ProgramNode(0...7)( [:a], StatementsNode(0...7)( - [AndWriteNode(0...7)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableAndWriteNode(0...7)( + (0...1), + (2...5), IntegerNode(6...7)(), - (2...5) + :a, + 0 )] ) ) diff --git a/test/yarp/snapshots/whitequark/var_op_asgn.txt b/test/yarp/snapshots/whitequark/var_op_asgn.txt index 08b724031b..4591e68c96 100644 --- a/test/yarp/snapshots/whitequark/var_op_asgn.txt +++ b/test/yarp/snapshots/whitequark/var_op_asgn.txt @@ -1,34 +1,36 @@ ProgramNode(0...53)( [:a], StatementsNode(0...53)( - [OperatorWriteNode(0...11)( - ClassVariableWriteNode(0...5)((0...5), nil, nil), + [ClassVariableOperatorWriteNode(0...11)( + (0...5), (6...8), - :|, - IntegerNode(9...11)() + IntegerNode(9...11)(), + :| ), - OperatorWriteNode(13...20)( - InstanceVariableWriteNode(13...15)((13...15), nil, nil), + InstanceVariableOperatorWriteNode(13...20)( + (13...15), (16...18), - :|, - IntegerNode(19...20)() + IntegerNode(19...20)(), + :| ), - OperatorWriteNode(22...28)( - LocalVariableWriteNode(22...23)(:a, 0, nil, (22...23), nil), + LocalVariableOperatorWriteNode(22...28)( + (22...23), (24...26), + IntegerNode(27...28)(), + :a, :+, - IntegerNode(27...28)() + 0 ), DefNode(30...53)( (34...35), nil, nil, StatementsNode(37...48)( - [OperatorWriteNode(37...48)( - ClassVariableWriteNode(37...42)((37...42), nil, nil), + [ClassVariableOperatorWriteNode(37...48)( + (37...42), (43...45), - :|, - IntegerNode(46...48)() + IntegerNode(46...48)(), + :| )] ), [], diff --git a/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt b/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt index f78329a1eb..21c1fb6e10 100644 --- a/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt +++ b/test/yarp/snapshots/whitequark/var_op_asgn_cmd.txt @@ -1,10 +1,9 @@ ProgramNode(0...12)( [:foo], StatementsNode(0...12)( - [OperatorWriteNode(0...12)( - LocalVariableWriteNode(0...3)(:foo, 0, nil, (0...3), nil), + [LocalVariableOperatorWriteNode(0...12)( + (0...3), (4...6), - :+, CallNode(7...12)( nil, nil, @@ -15,7 +14,10 @@ ProgramNode(0...12)( nil, 0, "m" - ) + ), + :foo, + :+, + 0 )] ) ) diff --git a/test/yarp/snapshots/whitequark/var_or_asgn.txt b/test/yarp/snapshots/whitequark/var_or_asgn.txt index bb2f8c6b39..3fb56b7f4a 100644 --- a/test/yarp/snapshots/whitequark/var_or_asgn.txt +++ b/test/yarp/snapshots/whitequark/var_or_asgn.txt @@ -1,10 +1,12 @@ ProgramNode(0...7)( [:a], StatementsNode(0...7)( - [OrWriteNode(0...7)( - LocalVariableWriteNode(0...1)(:a, 0, nil, (0...1), nil), + [LocalVariableOrWriteNode(0...7)( + (0...1), + (2...5), IntegerNode(6...7)(), - (2...5) + :a, + 0 )] ) ) diff --git a/yarp/config.yml b/yarp/config.yml index 3662c17609..24e8d0e227 100644 --- a/yarp/config.yml +++ b/yarp/config.yml @@ -399,19 +399,6 @@ nodes: left and right ^^^^^^^^^^^^^^ - - name: AndWriteNode - child_nodes: - - name: target - type: node - - name: value - type: node - - name: operator_loc - type: location - comment: | - Represents the use of the `&&=` operator. - - target &&= value - ^^^^^^^^^^^^^^^^ - name: ArgumentsNode child_nodes: - name: arguments @@ -738,6 +725,47 @@ nodes: class Foo end ^^^^^^^^^^^^^ + - name: ClassVariableAndWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `&&=` operator for assignment to a class variable. + + @@target &&= value + ^^^^^^^^^^^^^^^^ + - name: ClassVariableOperatorWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: operator + type: constant + comment: | + Represents assigning to a class variable using an operator that isn't `=`. + + @@target += value + ^^^^^^^^^^^^^^^^^ + - name: ClassVariableOrWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `||=` operator for assignment to a class variable. + + @@target ||= value + ^^^^^^^^^^^^^^^^^^ - name: ClassVariableReadNode comment: | Represents referencing a class variable. @@ -757,6 +785,61 @@ nodes: @@foo = 1 ^^^^^^^^^ + - name: ConstantAndWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `&&=` operator for assignment to a constant. + + Target &&= value + ^^^^^^^^^^^^^^^^ + - name: ConstantOperatorWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: operator + type: constant + comment: | + Represents assigning to a constant using an operator that isn't `=`. + + Target += value + ^^^^^^^^^^^^^^^ + - name: ConstantOrWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `||=` operator for assignment to a constant. + + Target ||= value + ^^^^^^^^^^^^^^^^ + - name: ConstantPathAndWriteNode + child_nodes: + - name: target + type: node + kind: ConstantPathNode + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `&&=` operator for assignment to a constant path. + + Parent::Child &&= value + ^^^^^^^^^^^^^^^^^^^^^^^ - name: ConstantPathNode child_nodes: - name: parent @@ -770,6 +853,36 @@ nodes: Foo::Bar ^^^^^^^^ + - name: ConstantPathOperatorWriteNode + child_nodes: + - name: target + type: node + kind: ConstantPathNode + - name: operator_loc + type: location + - name: value + type: node + - name: operator + type: constant + comment: | + Represents assigning to a constant path using an operator that isn't `=`. + + Parent::Child += value + ^^^^^^^^^^^^^^^^^^^^^^ + - name: ConstantPathOrWriteNode + child_nodes: + - name: target + type: node + kind: ConstantPathNode + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `||=` operator for assignment to a constant path. + + Parent::Child ||= value + ^^^^^^^^^^^^^^^^^^^^^^^ - name: ConstantPathWriteNode child_nodes: - name: target @@ -1012,6 +1125,47 @@ nodes: super ^^^^^ + - name: GlobalVariableAndWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `&&=` operator for assignment to a global variable. + + $target &&= value + ^^^^^^^^^^^^^^^^^ + - name: GlobalVariableOperatorWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: operator + type: constant + comment: | + Represents assigning to a global variable using an operator that isn't `=`. + + $target += value + ^^^^^^^^^^^^^^^^ + - name: GlobalVariableOrWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `||=` operator for assignment to a global variable. + + $target ||= value + ^^^^^^^^^^^^^^^^^ - name: GlobalVariableReadNode comment: | Represents referencing a global variable. @@ -1111,6 +1265,47 @@ nodes: case a; in b then c end ^^^^^^^^^^^ + - name: InstanceVariableAndWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `&&=` operator for assignment to an instance variable. + + @target &&= value + ^^^^^^^^^^^^^^^^^ + - name: InstanceVariableOperatorWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: operator + type: constant + comment: | + Represents assigning to an instance variable using an operator that isn't `=`. + + @target += value + ^^^^^^^^^^^^^^^^ + - name: InstanceVariableOrWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + comment: | + Represents the use of the `||=` operator for assignment to an instance variable. + + @target ||= value + ^^^^^^^^^^^^^^^^^ - name: InstanceVariableReadNode comment: | Represents referencing an instance variable. @@ -1248,6 +1443,59 @@ nodes: ->(value) { value * 2 } ^^^^^^^^^^^^^^^^^^^^^^^ + - name: LocalVariableAndWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: constant_id + type: constant + - name: depth + type: uint32 + comment: | + Represents the use of the `&&=` operator for assignment to a local variable. + + target &&= value + ^^^^^^^^^^^^^^^^ + - name: LocalVariableOperatorWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: constant_id + type: constant + - name: operator_id + type: constant + - name: depth + type: uint32 + comment: | + Represents assigning to a local variable using an operator that isn't `=`. + + target += value + ^^^^^^^^^^^^^^^ + - name: LocalVariableOrWriteNode + child_nodes: + - name: name_loc + type: location + - name: operator_loc + type: location + - name: value + type: node + - name: constant_id + type: constant + - name: depth + type: uint32 + comment: | + Represents the use of the `||=` operator for assignment to a local variable. + + target ||= value + ^^^^^^^^^^^^^^^^ - name: LocalVariableReadNode child_nodes: - name: constant_id @@ -1380,21 +1628,6 @@ nodes: $1 ^^ - - name: OperatorWriteNode - child_nodes: - - name: target - type: node - - name: operator_loc - type: location - - name: operator - type: constant - - name: value - type: node - comment: | - Represents the use of an operator on a write. - - target += value - ^^^^^^^^^^^^^^^ - name: OptionalParameterNode child_nodes: - name: constant_id @@ -1424,19 +1657,6 @@ nodes: left or right ^^^^^^^^^^^^^ - - name: OrWriteNode - child_nodes: - - name: target - type: node - - name: value - type: node - - name: operator_loc - type: location - comment: | - Represents the use of the `||=` operator. - - target ||= value - ^^^^^^^^^^^^^^^^ - name: ParametersNode child_nodes: - name: requireds diff --git a/yarp/yarp.c b/yarp/yarp.c index 012f8136e5..20d5628819 100644 --- a/yarp/yarp.c +++ b/yarp/yarp.c @@ -725,27 +725,6 @@ yp_and_node_create(yp_parser_t *parser, yp_node_t *left, const yp_token_t *opera return node; } -// Allocate and initialize a new AndWriteNode. -static yp_and_write_node_t * -yp_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { - yp_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_and_write_node_t); - - *node = (yp_and_write_node_t) { - { - .type = YP_NODE_AND_WRITE_NODE, - .location = { - .start = target->location.start, - .end = value->location.end - }, - }, - .target = target, - .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), - .value = value - }; - - return node; -} - // Allocate an initialize a new arguments node. static yp_arguments_node_t * yp_arguments_node_create(yp_parser_t *parser) { @@ -1575,6 +1554,74 @@ yp_class_node_create(yp_parser_t *parser, yp_constant_id_list_t *locals, const y return node; } +// Allocate and initialize a new ClassVariableAndWriteNode node. +static yp_class_variable_and_write_node_t * +yp_class_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_CLASS_VARIABLE_READ_NODE)); + assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); + yp_class_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_and_write_node_t); + + *node = (yp_class_variable_and_write_node_t) { + { + .type = YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + +// Allocate and initialize a new ClassVariableOperatorWriteNode node. +static yp_class_variable_operator_write_node_t * +yp_class_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + yp_class_variable_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_operator_write_node_t); + + *node = (yp_class_variable_operator_write_node_t) { + { + .type = YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1) + }; + + return node; +} + +// Allocate and initialize a new ClassVariableOrWriteNode node. +static yp_class_variable_or_write_node_t * +yp_class_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_CLASS_VARIABLE_READ_NODE)); + assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); + yp_class_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_class_variable_or_write_node_t); + + *node = (yp_class_variable_or_write_node_t) { + { + .type = YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + // Allocate and initialize a new ClassVariableReadNode node. static yp_class_variable_read_node_t * yp_class_variable_read_node_create(yp_parser_t *parser, const yp_token_t *token) { @@ -1605,6 +1652,72 @@ yp_class_variable_read_node_to_class_variable_write_node(yp_parser_t *parser, yp return node; } +// Allocate and initialize a new ConstantPathAndWriteNode node. +static yp_constant_path_and_write_node_t * +yp_constant_path_and_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); + yp_constant_path_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_and_write_node_t); + + *node = (yp_constant_path_and_write_node_t) { + { + .type = YP_NODE_CONSTANT_PATH_AND_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 ConstantPathOperatorWriteNode node. +static yp_constant_path_operator_write_node_t * +yp_constant_path_operator_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) { + yp_constant_path_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_operator_write_node_t); + + *node = (yp_constant_path_operator_write_node_t) { + { + .type = YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE, + .location = { + .start = target->base.location.start, + .end = value->location.end + } + }, + .target = target, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1) + }; + + return node; +} + +// Allocate and initialize a new ConstantPathOrWriteNode node. +static yp_constant_path_or_write_node_t * +yp_constant_path_or_write_node_create(yp_parser_t *parser, yp_constant_path_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); + yp_constant_path_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_path_or_write_node_t); + + *node = (yp_constant_path_or_write_node_t) { + { + .type = YP_NODE_CONSTANT_PATH_OR_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 ConstantPathNode node. static yp_constant_path_node_t * yp_constant_path_node_create(yp_parser_t *parser, yp_node_t *parent, const yp_token_t *delimiter, yp_node_t *child) { @@ -1647,6 +1760,74 @@ yp_constant_path_write_node_create(yp_parser_t *parser, yp_constant_path_node_t return node; } +// Allocate and initialize a new ConstantAndWriteNode node. +static yp_constant_and_write_node_t * +yp_constant_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_CONSTANT_READ_NODE)); + assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); + yp_constant_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_and_write_node_t); + + *node = (yp_constant_and_write_node_t) { + { + .type = YP_NODE_CONSTANT_AND_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + +// Allocate and initialize a new ConstantOperatorWriteNode node. +static yp_constant_operator_write_node_t * +yp_constant_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + yp_constant_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_operator_write_node_t); + + *node = (yp_constant_operator_write_node_t) { + { + .type = YP_NODE_CONSTANT_OPERATOR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1) + }; + + return node; +} + +// Allocate and initialize a new ConstantOrWriteNode node. +static yp_constant_or_write_node_t * +yp_constant_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_CONSTANT_READ_NODE)); + assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); + yp_constant_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_constant_or_write_node_t); + + *node = (yp_constant_or_write_node_t) { + { + .type = YP_NODE_CONSTANT_OR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + // Allocate and initialize a new ConstantReadNode node. static yp_constant_read_node_t * yp_constant_read_node_create(yp_parser_t *parser, const yp_token_t *name) { @@ -2081,6 +2262,74 @@ yp_hash_pattern_node_node_list_create(yp_parser_t *parser, yp_node_list_t *assoc return node; } +// Allocate and initialize a new GlobalVariableAndWriteNode node. +static yp_global_variable_and_write_node_t * +yp_global_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_GLOBAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_BACK_REFERENCE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_NUMBERED_REFERENCE_READ_NODE)); + assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); + yp_global_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_and_write_node_t); + + *node = (yp_global_variable_and_write_node_t) { + { + .type = YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + +// Allocate and initialize a new GlobalVariableOperatorWriteNode node. +static yp_global_variable_operator_write_node_t * +yp_global_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + yp_global_variable_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_operator_write_node_t); + + *node = (yp_global_variable_operator_write_node_t) { + { + .type = YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1) + }; + + return node; +} + +// Allocate and initialize a new GlobalVariableOrWriteNode node. +static yp_global_variable_or_write_node_t * +yp_global_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_GLOBAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_BACK_REFERENCE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_NUMBERED_REFERENCE_READ_NODE)); + assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); + yp_global_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_global_variable_or_write_node_t); + + *node = (yp_global_variable_or_write_node_t) { + { + .type = YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + // Allocate a new GlobalVariableReadNode node. static yp_global_variable_read_node_t * yp_global_variable_read_node_create(yp_parser_t *parser, const yp_token_t *name) { @@ -2371,6 +2620,74 @@ yp_in_node_create(yp_parser_t *parser, yp_node_t *pattern, yp_statements_node_t return node; } +// Allocate and initialize a new InstanceVariableAndWriteNode node. +static yp_instance_variable_and_write_node_t * +yp_instance_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_INSTANCE_VARIABLE_READ_NODE)); + assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); + yp_instance_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_and_write_node_t); + + *node = (yp_instance_variable_and_write_node_t) { + { + .type = YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + +// Allocate and initialize a new InstanceVariableOperatorWriteNode node. +static yp_instance_variable_operator_write_node_t * +yp_instance_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + yp_instance_variable_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_operator_write_node_t); + + *node = (yp_instance_variable_operator_write_node_t) { + { + .type = YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1) + }; + + return node; +} + +// Allocate and initialize a new InstanceVariableOrWriteNode node. +static yp_instance_variable_or_write_node_t * +yp_instance_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { + assert(YP_NODE_TYPE_P(target, YP_NODE_INSTANCE_VARIABLE_READ_NODE)); + assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); + yp_instance_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_instance_variable_or_write_node_t); + + *node = (yp_instance_variable_or_write_node_t) { + { + .type = YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value + }; + + return node; +} + // Allocate and initialize a new InstanceVariableReadNode node. static yp_instance_variable_read_node_t * yp_instance_variable_read_node_create(yp_parser_t *parser, const yp_token_t *token) { @@ -2644,6 +2961,80 @@ yp_lambda_node_create( return node; } +// Allocate and initialize a new LocalVariableAndWriteNode node. +static yp_local_variable_and_write_node_t * +yp_local_variable_and_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id, uint32_t depth) { + assert(YP_NODE_TYPE_P(target, YP_NODE_LOCAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_CALL_NODE)); + assert(operator->type == YP_TOKEN_AMPERSAND_AMPERSAND_EQUAL); + yp_local_variable_and_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_and_write_node_t); + + *node = (yp_local_variable_and_write_node_t) { + { + .type = YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .constant_id = constant_id, + .depth = depth + }; + + return node; +} + +// Allocate and initialize a new LocalVariableOperatorWriteNode node. +static yp_local_variable_operator_write_node_t * +yp_local_variable_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id, uint32_t depth) { + yp_local_variable_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_operator_write_node_t); + + *node = (yp_local_variable_operator_write_node_t) { + { + .type = YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .constant_id = constant_id, + .operator_id = yp_parser_constant_id_location(parser, operator->start, operator->end - 1), + .depth = depth + }; + + return node; +} + +// Allocate and initialize a new LocalVariableOrWriteNode node. +static yp_local_variable_or_write_node_t * +yp_local_variable_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value, yp_constant_id_t constant_id, uint32_t depth) { + assert(YP_NODE_TYPE_P(target, YP_NODE_LOCAL_VARIABLE_READ_NODE) || YP_NODE_TYPE_P(target, YP_NODE_CALL_NODE)); + assert(operator->type == YP_TOKEN_PIPE_PIPE_EQUAL); + yp_local_variable_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_local_variable_or_write_node_t); + + *node = (yp_local_variable_or_write_node_t) { + { + .type = YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE, + .location = { + .start = target->location.start, + .end = value->location.end + } + }, + .name_loc = target->location, + .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), + .value = value, + .constant_id = constant_id, + .depth = depth + }; + + return node; +} + // Allocate a new LocalVariableReadNode node. static yp_local_variable_read_node_t * yp_local_variable_read_node_create(yp_parser_t *parser, const yp_token_t *name, uint32_t depth) { @@ -2879,28 +3270,6 @@ yp_numbered_reference_read_node_create(yp_parser_t *parser, const yp_token_t *na return node; } -// Allocate and initialize a new OperatorWriteNode. -static yp_operator_write_node_t * -yp_operator_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { - yp_operator_write_node_t *node = YP_ALLOC_NODE(parser, yp_operator_write_node_t); - - *node = (yp_operator_write_node_t) { - { - .type = YP_NODE_OPERATOR_WRITE_NODE, - .location = { - .start = target->location.start, - .end = value->location.end - }, - }, - .target = target, - .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), - .operator = yp_parser_constant_id_location(parser, operator->start, operator->end - 1), - .value = value - }; - - return node; -} - // Allocate a new OptionalParameterNode node. static yp_optional_parameter_node_t * yp_optional_parameter_node_create(yp_parser_t *parser, const yp_token_t *name, const yp_token_t *operator, yp_node_t *value) { @@ -2944,27 +3313,6 @@ yp_or_node_create(yp_parser_t *parser, yp_node_t *left, const yp_token_t *operat return node; } -// Allocate and initialize a new OrWriteNode. -static yp_or_write_node_t * -yp_or_write_node_create(yp_parser_t *parser, yp_node_t *target, const yp_token_t *operator, yp_node_t *value) { - yp_or_write_node_t *node = YP_ALLOC_NODE(parser, yp_or_write_node_t); - - *node = (yp_or_write_node_t) { - { - .type = YP_NODE_OR_WRITE_NODE, - .location = { - .start = target->location.start, - .end = value->location.end - }, - }, - .target = target, - .operator_loc = YP_LOCATION_TOKEN_VALUE(operator), - .value = value - }; - - return node; -} - // Allocate and initialize a new ParametersNode node. static yp_parameters_node_t * yp_parameters_node_create(yp_parser_t *parser) { @@ -4074,13 +4422,15 @@ yp_parser_local_depth(yp_parser_t *parser, yp_token_t *token) { } // Add a local variable from a location to the current scope. -static void +static yp_constant_id_t yp_parser_local_add_location(yp_parser_t *parser, const char *start, const char *end) { yp_constant_id_t constant_id = yp_parser_constant_id_location(parser, start, end); if (!yp_constant_id_list_includes(&parser->current_scope->locals, constant_id)) { yp_constant_id_list_append(&parser->current_scope->locals, constant_id); } + + return constant_id; } // Add a local variable from a token to the current scope. @@ -12259,19 +12609,57 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t case YP_NODE_NUMBERED_REFERENCE_READ_NODE: yp_diagnostic_list_append(&parser->error_list, node->location.start, node->location.end, "Can't set variable"); /* fallthrough */ - case YP_NODE_CLASS_VARIABLE_READ_NODE: - case YP_NODE_CONSTANT_PATH_NODE: - case YP_NODE_CONSTANT_READ_NODE: - case YP_NODE_GLOBAL_VARIABLE_READ_NODE: - case YP_NODE_INSTANCE_VARIABLE_READ_NODE: - case YP_NODE_LOCAL_VARIABLE_READ_NODE: { + case YP_NODE_GLOBAL_VARIABLE_READ_NODE: { parser_lex(parser); - yp_token_t operator = not_provided(parser); - node = parse_target(parser, node, &operator, NULL); + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); + yp_node_t *result = (yp_node_t *) yp_global_variable_and_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_CLASS_VARIABLE_READ_NODE: { + parser_lex(parser); yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); - return (yp_node_t *) yp_and_write_node_create(parser, node, &token, value); + yp_node_t *result = (yp_node_t *) yp_class_variable_and_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_CONSTANT_PATH_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); + return (yp_node_t *) yp_constant_path_and_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value); + } + case YP_NODE_CONSTANT_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); + yp_node_t *result = (yp_node_t *) yp_constant_and_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_INSTANCE_VARIABLE_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); + yp_node_t *result = (yp_node_t *) yp_instance_variable_and_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_LOCAL_VARIABLE_READ_NODE: { + yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node; + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); + yp_node_t *result = (yp_node_t *) yp_local_variable_and_write_node_create(parser, node, &token, value, cast->constant_id, cast->depth); + + yp_node_destroy(parser, node); + return result; } case YP_NODE_CALL_NODE: { yp_call_node_t *call_node = (yp_call_node_t *) node; @@ -12281,19 +12669,18 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t // will transform it into a local variable write. if (yp_call_node_variable_call_p(call_node)) { yp_location_t message_loc = call_node->message_loc; - yp_parser_local_add_location(parser, message_loc.start, message_loc.end); + yp_constant_id_t constant_id = yp_parser_local_add_location(parser, message_loc.start, message_loc.end); if (token_is_numbered_parameter(message_loc.start, message_loc.end)) { yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter"); } parser_lex(parser); - - yp_token_t operator = not_provided(parser); - node = parse_target(parser, node, &operator, NULL); - yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); - return (yp_node_t *) yp_and_write_node_create(parser, node, &token, value); + yp_node_t *result = (yp_node_t *) yp_local_variable_and_write_node_create(parser, node, &token, value, constant_id, 0); + + yp_node_destroy(parser, node); + return result; } parser_lex(parser); @@ -12325,19 +12712,57 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t case YP_NODE_NUMBERED_REFERENCE_READ_NODE: yp_diagnostic_list_append(&parser->error_list, node->location.start, node->location.end, "Can't set variable"); /* fallthrough */ - case YP_NODE_CLASS_VARIABLE_READ_NODE: - case YP_NODE_CONSTANT_PATH_NODE: - case YP_NODE_CONSTANT_READ_NODE: - case YP_NODE_GLOBAL_VARIABLE_READ_NODE: - case YP_NODE_INSTANCE_VARIABLE_READ_NODE: - case YP_NODE_LOCAL_VARIABLE_READ_NODE: { + case YP_NODE_GLOBAL_VARIABLE_READ_NODE: { parser_lex(parser); - yp_token_t operator = not_provided(parser); - node = parse_target(parser, node, &operator, NULL); + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); + yp_node_t *result = (yp_node_t *) yp_global_variable_or_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_CLASS_VARIABLE_READ_NODE: { + parser_lex(parser); yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); - return (yp_node_t *) yp_or_write_node_create(parser, node, &token, value); + yp_node_t *result = (yp_node_t *) yp_class_variable_or_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_CONSTANT_PATH_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); + return (yp_node_t *) yp_constant_path_or_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value); + } + case YP_NODE_CONSTANT_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); + yp_node_t *result = (yp_node_t *) yp_constant_or_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_INSTANCE_VARIABLE_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); + yp_node_t *result = (yp_node_t *) yp_instance_variable_or_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_LOCAL_VARIABLE_READ_NODE: { + yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node; + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); + yp_node_t *result = (yp_node_t *) yp_local_variable_or_write_node_create(parser, node, &token, value, cast->constant_id, cast->depth); + + yp_node_destroy(parser, node); + return result; } case YP_NODE_CALL_NODE: { yp_call_node_t *call_node = (yp_call_node_t *) node; @@ -12347,19 +12772,18 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t // will transform it into a local variable write. if (yp_call_node_variable_call_p(call_node)) { yp_location_t message_loc = call_node->message_loc; - yp_parser_local_add_location(parser, message_loc.start, message_loc.end); + yp_constant_id_t constant_id = yp_parser_local_add_location(parser, message_loc.start, message_loc.end); if (token_is_numbered_parameter(message_loc.start, message_loc.end)) { yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter"); } parser_lex(parser); - - yp_token_t operator = not_provided(parser); - node = parse_target(parser, node, &operator, NULL); - yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after ||="); - return (yp_node_t *) yp_or_write_node_create(parser, node, &token, value); + yp_node_t *result = (yp_node_t *) yp_local_variable_or_write_node_create(parser, node, &token, value, constant_id, 0); + + yp_node_destroy(parser, node); + return result; } parser_lex(parser); @@ -12401,19 +12825,57 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t case YP_NODE_NUMBERED_REFERENCE_READ_NODE: yp_diagnostic_list_append(&parser->error_list, node->location.start, node->location.end, "Can't set variable"); /* fallthrough */ - case YP_NODE_CLASS_VARIABLE_READ_NODE: - case YP_NODE_CONSTANT_PATH_NODE: - case YP_NODE_CONSTANT_READ_NODE: - case YP_NODE_GLOBAL_VARIABLE_READ_NODE: - case YP_NODE_INSTANCE_VARIABLE_READ_NODE: - case YP_NODE_LOCAL_VARIABLE_READ_NODE: { + case YP_NODE_GLOBAL_VARIABLE_READ_NODE: { parser_lex(parser); - yp_token_t operator = not_provided(parser); - node = parse_target(parser, node, &operator, NULL); + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + yp_node_t *result = (yp_node_t *) yp_global_variable_operator_write_node_create(parser, node, &token, value); - yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator"); - return (yp_node_t *) yp_operator_write_node_create(parser, node, &token, value); + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_CLASS_VARIABLE_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + yp_node_t *result = (yp_node_t *) yp_class_variable_operator_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_CONSTANT_PATH_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + return (yp_node_t *) yp_constant_path_operator_write_node_create(parser, (yp_constant_path_node_t *) node, &token, value); + } + case YP_NODE_CONSTANT_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + yp_node_t *result = (yp_node_t *) yp_constant_operator_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_INSTANCE_VARIABLE_READ_NODE: { + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + yp_node_t *result = (yp_node_t *) yp_instance_variable_operator_write_node_create(parser, node, &token, value); + + yp_node_destroy(parser, node); + return result; + } + case YP_NODE_LOCAL_VARIABLE_READ_NODE: { + yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node; + parser_lex(parser); + + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + yp_node_t *result = (yp_node_t *) yp_local_variable_operator_write_node_create(parser, node, &token, value, cast->constant_id, cast->depth); + + yp_node_destroy(parser, node); + return result; } case YP_NODE_CALL_NODE: { yp_call_node_t *call_node = (yp_call_node_t *) node; @@ -12423,19 +12885,18 @@ parse_expression_infix(yp_parser_t *parser, yp_node_t *node, yp_binding_power_t // will transform it into a local variable write. if (yp_call_node_variable_call_p(call_node)) { yp_location_t message_loc = call_node->message_loc; - yp_parser_local_add_location(parser, message_loc.start, message_loc.end); + yp_constant_id_t constant_id = yp_parser_local_add_location(parser, message_loc.start, message_loc.end); if (token_is_numbered_parameter(message_loc.start, message_loc.end)) { yp_diagnostic_list_append(&parser->error_list, message_loc.start, message_loc.end, "reserved for numbered parameter"); } parser_lex(parser); + yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after the operator."); + yp_node_t *result = (yp_node_t *) yp_local_variable_operator_write_node_create(parser, node, &token, value, constant_id, 0); - yp_token_t operator = not_provided(parser); - node = parse_target(parser, node, &operator, NULL); - - yp_node_t *value = parse_expression(parser, binding_power, "Expected a value after &&="); - return (yp_node_t *) yp_operator_write_node_create(parser, node, &token, value); + yp_node_destroy(parser, node); + return result; } yp_token_t operator = not_provided(parser);