diff options
Diffstat (limited to 'test/prism/snapshots/unparser/corpus/literal/opasgn.txt')
| -rw-r--r-- | test/prism/snapshots/unparser/corpus/literal/opasgn.txt | 509 |
1 files changed, 509 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/literal/opasgn.txt b/test/prism/snapshots/unparser/corpus/literal/opasgn.txt new file mode 100644 index 0000000000..8dc0849638 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/opasgn.txt @@ -0,0 +1,509 @@ +@ ProgramNode (location: (1,0)-(24,10)) +├── locals: [:a, :h] +└── statements: + @ StatementsNode (location: (1,0)-(24,10)) + └── body: (length: 24) + ├── @ LocalVariableOperatorWriteNode (location: (1,0)-(1,6)) + │ ├── name_loc: (1,0)-(1,1) = "a" + │ ├── operator_loc: (1,2)-(1,4) = "+=" + │ ├── value: + │ │ @ IntegerNode (location: (1,5)-(1,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── operator: :+ + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (2,0)-(2,6)) + │ ├── name_loc: (2,0)-(2,1) = "a" + │ ├── operator_loc: (2,2)-(2,4) = "-=" + │ ├── value: + │ │ @ IntegerNode (location: (2,5)-(2,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── operator: :- + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,7)) + │ ├── name_loc: (3,0)-(3,1) = "a" + │ ├── operator_loc: (3,2)-(3,5) = "**=" + │ ├── value: + │ │ @ IntegerNode (location: (3,6)-(3,7)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── operator: :** + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (4,0)-(4,6)) + │ ├── name_loc: (4,0)-(4,1) = "a" + │ ├── operator_loc: (4,2)-(4,4) = "*=" + │ ├── value: + │ │ @ IntegerNode (location: (4,5)-(4,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── operator: :* + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (5,0)-(5,6)) + │ ├── name_loc: (5,0)-(5,1) = "a" + │ ├── operator_loc: (5,2)-(5,4) = "/=" + │ ├── value: + │ │ @ IntegerNode (location: (5,5)-(5,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── operator: :/ + │ └── depth: 0 + ├── @ LocalVariableAndWriteNode (location: (6,0)-(6,7)) + │ ├── name_loc: (6,0)-(6,1) = "a" + │ ├── operator_loc: (6,2)-(6,5) = "&&=" + │ ├── value: + │ │ @ CallNode (location: (6,6)-(6,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (6,6)-(6,7) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── name: :a + │ └── depth: 0 + ├── @ LocalVariableOrWriteNode (location: (7,0)-(7,7)) + │ ├── name_loc: (7,0)-(7,1) = "a" + │ ├── operator_loc: (7,2)-(7,5) = "||=" + │ ├── value: + │ │ @ IntegerNode (location: (7,6)-(7,7)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ └── depth: 0 + ├── @ CallNode (location: (8,0)-(8,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (8,0)-(8,9)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (8,1)-(8,8)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableOrWriteNode (location: (8,1)-(8,8)) + │ │ │ ├── name_loc: (8,1)-(8,2) = "a" + │ │ │ ├── operator_loc: (8,3)-(8,6) = "||=" + │ │ │ ├── value: + │ │ │ │ @ IntegerNode (location: (8,7)-(8,8)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── opening_loc: (8,0)-(8,1) = "(" + │ │ └── closing_loc: (8,8)-(8,9) = ")" + │ ├── call_operator_loc: (8,9)-(8,10) = "." + │ ├── name: :bar + │ ├── message_loc: (8,10)-(8,13) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (9,0)-(9,17)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ ParenthesesNode (location: (9,0)-(9,10)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (9,1)-(9,9)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableOrWriteNode (location: (9,1)-(9,9)) + │ │ │ ├── name_loc: (9,1)-(9,2) = "h" + │ │ │ ├── operator_loc: (9,3)-(9,6) = "||=" + │ │ │ ├── value: + │ │ │ │ @ HashNode (location: (9,7)-(9,9)) + │ │ │ │ ├── opening_loc: (9,7)-(9,8) = "{" + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ └── closing_loc: (9,8)-(9,9) = "}" + │ │ │ ├── name: :h + │ │ │ └── depth: 0 + │ │ ├── opening_loc: (9,0)-(9,1) = "(" + │ │ └── closing_loc: (9,9)-(9,10) = ")" + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (9,10)-(9,13) = "[k]" + │ ├── opening_loc: (9,10)-(9,11) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (9,11)-(9,17)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (9,11)-(9,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :k + │ │ │ ├── message_loc: (9,11)-(9,12) = "k" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (9,16)-(9,17)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :v + │ │ ├── message_loc: (9,16)-(9,17) = "v" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (9,12)-(9,13) = "]" + │ └── block: ∅ + ├── @ CallOperatorWriteNode (location: (10,0)-(10,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (10,0)-(10,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (10,1)-(10,2) = "." + │ ├── message_loc: (10,2)-(10,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator: :+ + │ ├── operator_loc: (10,4)-(10,6) = "+=" + │ └── value: + │ @ IntegerNode (location: (10,7)-(10,8)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ CallOperatorWriteNode (location: (11,0)-(11,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (11,0)-(11,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (11,1)-(11,2) = "." + │ ├── message_loc: (11,2)-(11,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator: :- + │ ├── operator_loc: (11,4)-(11,6) = "-=" + │ └── value: + │ @ IntegerNode (location: (11,7)-(11,8)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ CallOperatorWriteNode (location: (12,0)-(12,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (12,0)-(12,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (12,1)-(12,2) = "." + │ ├── message_loc: (12,2)-(12,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator: :** + │ ├── operator_loc: (12,4)-(12,7) = "**=" + │ └── value: + │ @ IntegerNode (location: (12,8)-(12,9)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ CallOperatorWriteNode (location: (13,0)-(13,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (13,0)-(13,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (13,1)-(13,2) = "." + │ ├── message_loc: (13,2)-(13,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator: :* + │ ├── operator_loc: (13,4)-(13,6) = "*=" + │ └── value: + │ @ IntegerNode (location: (13,7)-(13,8)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ CallOperatorWriteNode (location: (14,0)-(14,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (14,0)-(14,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (14,1)-(14,2) = "." + │ ├── message_loc: (14,2)-(14,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator: :/ + │ ├── operator_loc: (14,4)-(14,6) = "/=" + │ └── value: + │ @ IntegerNode (location: (14,7)-(14,8)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ CallAndWriteNode (location: (15,0)-(15,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (15,0)-(15,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (15,1)-(15,2) = "." + │ ├── message_loc: (15,2)-(15,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator_loc: (15,4)-(15,7) = "&&=" + │ └── value: + │ @ CallNode (location: (15,8)-(15,9)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :b + │ ├── message_loc: (15,8)-(15,9) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallOrWriteNode (location: (16,0)-(16,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (16,0)-(16,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: (16,1)-(16,2) = "." + │ ├── message_loc: (16,2)-(16,3) = "b" + │ ├── read_name: :b + │ ├── write_name: :b= + │ ├── operator_loc: (16,4)-(16,7) = "||=" + │ └── value: + │ @ IntegerNode (location: (16,8)-(16,9)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ IndexOperatorWriteNode (location: (17,0)-(17,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (17,0)-(17,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (17,1)-(17,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (17,2)-(17,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (17,2)-(17,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (17,2)-(17,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (17,3)-(17,4) = "]" + │ ├── block: ∅ + │ ├── operator: :+ + │ ├── operator_loc: (17,5)-(17,7) = "+=" + │ └── value: + │ @ IntegerNode (location: (17,8)-(17,9)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ IndexOperatorWriteNode (location: (18,0)-(18,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (18,0)-(18,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (18,1)-(18,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (18,2)-(18,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (18,2)-(18,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (18,2)-(18,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (18,3)-(18,4) = "]" + │ ├── block: ∅ + │ ├── operator: :- + │ ├── operator_loc: (18,5)-(18,7) = "-=" + │ └── value: + │ @ IntegerNode (location: (18,8)-(18,9)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ IndexOperatorWriteNode (location: (19,0)-(19,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (19,0)-(19,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (19,1)-(19,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (19,2)-(19,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (19,2)-(19,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (19,2)-(19,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (19,3)-(19,4) = "]" + │ ├── block: ∅ + │ ├── operator: :** + │ ├── operator_loc: (19,5)-(19,8) = "**=" + │ └── value: + │ @ IntegerNode (location: (19,9)-(19,10)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ IndexOperatorWriteNode (location: (20,0)-(20,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (20,0)-(20,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (20,1)-(20,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (20,2)-(20,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (20,2)-(20,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (20,2)-(20,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (20,3)-(20,4) = "]" + │ ├── block: ∅ + │ ├── operator: :* + │ ├── operator_loc: (20,5)-(20,7) = "*=" + │ └── value: + │ @ IntegerNode (location: (20,8)-(20,9)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ IndexOperatorWriteNode (location: (21,0)-(21,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (21,0)-(21,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (21,1)-(21,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (21,2)-(21,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (21,2)-(21,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (21,2)-(21,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (21,3)-(21,4) = "]" + │ ├── block: ∅ + │ ├── operator: :/ + │ ├── operator_loc: (21,5)-(21,7) = "/=" + │ └── value: + │ @ IntegerNode (location: (21,8)-(21,9)) + │ ├── flags: decimal + │ └── value: 2 + ├── @ IndexAndWriteNode (location: (22,0)-(22,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (22,0)-(22,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (22,1)-(22,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (22,2)-(22,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (22,2)-(22,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (22,2)-(22,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (22,3)-(22,4) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (22,5)-(22,8) = "&&=" + │ └── value: + │ @ CallNode (location: (22,9)-(22,10)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :b + │ ├── message_loc: (22,9)-(22,10) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ IndexOrWriteNode (location: (23,0)-(23,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (23,0)-(23,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (23,1)-(23,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (23,2)-(23,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (23,2)-(23,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (23,2)-(23,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (23,3)-(23,4) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (23,5)-(23,8) = "||=" + │ └── value: + │ @ IntegerNode (location: (23,9)-(23,10)) + │ ├── flags: decimal + │ └── value: 2 + └── @ CallOperatorWriteNode (location: (24,0)-(24,10)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (24,0)-(24,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (24,0)-(24,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: (24,3)-(24,4) = "." + ├── message_loc: (24,4)-(24,5) = "A" + ├── read_name: :A + ├── write_name: :A= + ├── operator: :+ + ├── operator_loc: (24,6)-(24,8) = "+=" + └── value: + @ IntegerNode (location: (24,9)-(24,10)) + ├── flags: decimal + └── value: 1 |