diff options
Diffstat (limited to 'test/prism/snapshots/unparser/corpus')
46 files changed, 14944 insertions, 0 deletions
diff --git a/test/prism/snapshots/unparser/corpus/literal/alias.txt b/test/prism/snapshots/unparser/corpus/literal/alias.txt new file mode 100644 index 0000000000..18ddc86d4f --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/alias.txt @@ -0,0 +1,29 @@ +@ ProgramNode (location: (1,0)-(2,15)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(2,15)) + └── body: (length: 2) + ├── @ AliasGlobalVariableNode (location: (1,0)-(1,15)) + │ ├── new_name: + │ │ @ GlobalVariableReadNode (location: (1,6)-(1,10)) + │ │ └── name: :$foo + │ ├── old_name: + │ │ @ GlobalVariableReadNode (location: (1,11)-(1,15)) + │ │ └── name: :$bar + │ └── keyword_loc: (1,0)-(1,5) = "alias" + └── @ AliasMethodNode (location: (2,0)-(2,15)) + ├── new_name: + │ @ SymbolNode (location: (2,6)-(2,10)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (2,6)-(2,7) = ":" + │ ├── value_loc: (2,7)-(2,10) = "foo" + │ ├── closing_loc: ∅ + │ └── unescaped: "foo" + ├── old_name: + │ @ SymbolNode (location: (2,11)-(2,15)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (2,11)-(2,12) = ":" + │ ├── value_loc: (2,12)-(2,15) = "bar" + │ ├── closing_loc: ∅ + │ └── unescaped: "bar" + └── keyword_loc: (2,0)-(2,5) = "alias" diff --git a/test/prism/snapshots/unparser/corpus/literal/assignment.txt b/test/prism/snapshots/unparser/corpus/literal/assignment.txt new file mode 100644 index 0000000000..7d3cc389c6 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/assignment.txt @@ -0,0 +1,1076 @@ +@ ProgramNode (location: (1,0)-(51,17)) +├── locals: [:a, :b, :foo, :c, :x] +└── statements: + @ StatementsNode (location: (1,0)-(51,17)) + └── body: (length: 43) + ├── @ GlobalVariableWriteNode (location: (1,0)-(1,6)) + │ ├── name: :$a + │ ├── name_loc: (1,0)-(1,2) = "$a" + │ ├── value: + │ │ @ IntegerNode (location: (1,5)-(1,6)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (1,3)-(1,4) = "=" + ├── @ MultiWriteNode (location: (2,0)-(2,17)) + │ ├── lefts: (length: 2) + │ │ ├── @ GlobalVariableTargetNode (location: (2,1)-(2,3)) + │ │ │ └── name: :$a + │ │ └── @ GlobalVariableTargetNode (location: (2,5)-(2,7)) + │ │ └── name: :$b + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (2,0)-(2,1) = "(" + │ ├── rparen_loc: (2,7)-(2,8) = ")" + │ ├── operator_loc: (2,9)-(2,10) = "=" + │ └── value: + │ @ ArrayNode (location: (2,11)-(2,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (2,12)-(2,13)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (2,15)-(2,16)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (2,11)-(2,12) = "[" + │ └── closing_loc: (2,16)-(2,17) = "]" + ├── @ MultiWriteNode (location: (3,0)-(3,13)) + │ ├── lefts: (length: 2) + │ │ ├── @ MultiTargetNode (location: (3,1)-(3,5)) + │ │ │ ├── lefts: (length: 1) + │ │ │ │ └── @ LocalVariableTargetNode (location: (3,2)-(3,3)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── rest: + │ │ │ │ @ ImplicitRestNode (location: (3,3)-(3,4)) + │ │ │ ├── rights: (length: 0) + │ │ │ ├── lparen_loc: (3,1)-(3,2) = "(" + │ │ │ └── rparen_loc: (3,4)-(3,5) = ")" + │ │ └── @ LocalVariableTargetNode (location: (3,7)-(3,8)) + │ │ ├── name: :b + │ │ └── depth: 0 + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (3,0)-(3,1) = "(" + │ ├── rparen_loc: (3,8)-(3,9) = ")" + │ ├── operator_loc: (3,10)-(3,11) = "=" + │ └── value: + │ @ IntegerNode (location: (3,12)-(3,13)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ MultiWriteNode (location: (4,0)-(4,9)) + │ ├── lefts: (length: 0) + │ ├── rest: + │ │ @ SplatNode (location: (4,1)-(4,3)) + │ │ ├── operator_loc: (4,1)-(4,2) = "*" + │ │ └── expression: + │ │ @ LocalVariableTargetNode (location: (4,2)-(4,3)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── rights: (length: 0) + │ ├── lparen_loc: (4,0)-(4,1) = "(" + │ ├── rparen_loc: (4,3)-(4,4) = ")" + │ ├── operator_loc: (4,5)-(4,6) = "=" + │ └── value: + │ @ ArrayNode (location: (4,7)-(4,9)) + │ ├── flags: ∅ + │ ├── elements: (length: 0) + │ ├── opening_loc: (4,7)-(4,8) = "[" + │ └── closing_loc: (4,8)-(4,9) = "]" + ├── @ MultiWriteNode (location: (5,0)-(5,15)) + │ ├── lefts: (length: 0) + │ ├── rest: + │ │ @ SplatNode (location: (5,1)-(5,5)) + │ │ ├── operator_loc: (5,1)-(5,2) = "*" + │ │ └── expression: + │ │ @ LocalVariableTargetNode (location: (5,2)-(5,5)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── rights: (length: 0) + │ ├── lparen_loc: (5,0)-(5,1) = "(" + │ ├── rparen_loc: (5,5)-(5,6) = ")" + │ ├── operator_loc: (5,7)-(5,8) = "=" + │ └── value: + │ @ ArrayNode (location: (5,9)-(5,15)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (5,10)-(5,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (5,13)-(5,14)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (5,9)-(5,10) = "[" + │ └── closing_loc: (5,14)-(5,15) = "]" + ├── @ MultiWriteNode (location: (6,0)-(6,19)) + │ ├── lefts: (length: 2) + │ │ ├── @ ClassVariableTargetNode (location: (6,1)-(6,4)) + │ │ │ └── name: :@@a + │ │ └── @ ClassVariableTargetNode (location: (6,6)-(6,9)) + │ │ └── name: :@@b + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (6,0)-(6,1) = "(" + │ ├── rparen_loc: (6,9)-(6,10) = ")" + │ ├── operator_loc: (6,11)-(6,12) = "=" + │ └── value: + │ @ ArrayNode (location: (6,13)-(6,19)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (6,14)-(6,15)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (6,17)-(6,18)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (6,13)-(6,14) = "[" + │ └── closing_loc: (6,18)-(6,19) = "]" + ├── @ MultiWriteNode (location: (7,0)-(7,17)) + │ ├── lefts: (length: 2) + │ │ ├── @ InstanceVariableTargetNode (location: (7,1)-(7,3)) + │ │ │ └── name: :@a + │ │ └── @ InstanceVariableTargetNode (location: (7,5)-(7,7)) + │ │ └── name: :@b + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (7,0)-(7,1) = "(" + │ ├── rparen_loc: (7,7)-(7,8) = ")" + │ ├── operator_loc: (7,9)-(7,10) = "=" + │ └── value: + │ @ ArrayNode (location: (7,11)-(7,17)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (7,12)-(7,13)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (7,15)-(7,16)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (7,11)-(7,12) = "[" + │ └── closing_loc: (7,16)-(7,17) = "]" + ├── @ MultiWriteNode (location: (8,0)-(8,25)) + │ ├── lefts: (length: 2) + │ │ ├── @ LocalVariableTargetNode (location: (8,1)-(8,2)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ └── @ MultiTargetNode (location: (8,4)-(8,10)) + │ │ ├── lefts: (length: 2) + │ │ │ ├── @ LocalVariableTargetNode (location: (8,5)-(8,6)) + │ │ │ │ ├── name: :b + │ │ │ │ └── depth: 0 + │ │ │ └── @ LocalVariableTargetNode (location: (8,8)-(8,9)) + │ │ │ ├── name: :c + │ │ │ └── depth: 0 + │ │ ├── rest: ∅ + │ │ ├── rights: (length: 0) + │ │ ├── lparen_loc: (8,4)-(8,5) = "(" + │ │ └── rparen_loc: (8,9)-(8,10) = ")" + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (8,0)-(8,1) = "(" + │ ├── rparen_loc: (8,10)-(8,11) = ")" + │ ├── operator_loc: (8,12)-(8,13) = "=" + │ └── value: + │ @ ArrayNode (location: (8,14)-(8,25)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (8,15)-(8,16)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ ArrayNode (location: (8,18)-(8,24)) + │ │ ├── flags: ∅ + │ │ ├── elements: (length: 2) + │ │ │ ├── @ IntegerNode (location: (8,19)-(8,20)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ └── @ IntegerNode (location: (8,22)-(8,23)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── opening_loc: (8,18)-(8,19) = "[" + │ │ └── closing_loc: (8,23)-(8,24) = "]" + │ ├── opening_loc: (8,14)-(8,15) = "[" + │ └── closing_loc: (8,24)-(8,25) = "]" + ├── @ MultiWriteNode (location: (9,0)-(9,15)) + │ ├── lefts: (length: 1) + │ │ └── @ LocalVariableTargetNode (location: (9,1)-(9,2)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── rest: + │ │ @ SplatNode (location: (9,4)-(9,5)) + │ │ ├── operator_loc: (9,4)-(9,5) = "*" + │ │ └── expression: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (9,0)-(9,1) = "(" + │ ├── rparen_loc: (9,5)-(9,6) = ")" + │ ├── operator_loc: (9,7)-(9,8) = "=" + │ └── value: + │ @ ArrayNode (location: (9,9)-(9,15)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (9,10)-(9,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (9,13)-(9,14)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (9,9)-(9,10) = "[" + │ └── closing_loc: (9,14)-(9,15) = "]" + ├── @ MultiWriteNode (location: (10,0)-(10,18)) + │ ├── lefts: (length: 1) + │ │ └── @ LocalVariableTargetNode (location: (10,1)-(10,2)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── rest: + │ │ @ SplatNode (location: (10,4)-(10,8)) + │ │ ├── operator_loc: (10,4)-(10,5) = "*" + │ │ └── expression: + │ │ @ LocalVariableTargetNode (location: (10,5)-(10,8)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── rights: (length: 0) + │ ├── lparen_loc: (10,0)-(10,1) = "(" + │ ├── rparen_loc: (10,8)-(10,9) = ")" + │ ├── operator_loc: (10,10)-(10,11) = "=" + │ └── value: + │ @ ArrayNode (location: (10,12)-(10,18)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (10,13)-(10,14)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (10,16)-(10,17)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (10,12)-(10,13) = "[" + │ └── closing_loc: (10,17)-(10,18) = "]" + ├── @ MultiWriteNode (location: (11,0)-(11,15)) + │ ├── lefts: (length: 2) + │ │ ├── @ LocalVariableTargetNode (location: (11,1)-(11,2)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ └── @ LocalVariableTargetNode (location: (11,4)-(11,5)) + │ │ ├── name: :b + │ │ └── depth: 0 + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (11,0)-(11,1) = "(" + │ ├── rparen_loc: (11,5)-(11,6) = ")" + │ ├── operator_loc: (11,7)-(11,8) = "=" + │ └── value: + │ @ ArrayNode (location: (11,9)-(11,15)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (11,10)-(11,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (11,13)-(11,14)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (11,9)-(11,10) = "[" + │ └── closing_loc: (11,14)-(11,15) = "]" + ├── @ MultiWriteNode (location: (12,0)-(12,12)) + │ ├── lefts: (length: 2) + │ │ ├── @ LocalVariableTargetNode (location: (12,1)-(12,2)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ └── @ LocalVariableTargetNode (location: (12,4)-(12,5)) + │ │ ├── name: :b + │ │ └── depth: 0 + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (12,0)-(12,1) = "(" + │ ├── rparen_loc: (12,5)-(12,6) = ")" + │ ├── operator_loc: (12,7)-(12,8) = "=" + │ └── value: + │ @ LocalVariableReadNode (location: (12,9)-(12,12)) + │ ├── name: :foo + │ └── depth: 0 + ├── @ MultiWriteNode (location: (13,0)-(13,10)) + │ ├── lefts: (length: 1) + │ │ └── @ LocalVariableTargetNode (location: (13,1)-(13,2)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── rest: + │ │ @ ImplicitRestNode (location: (13,2)-(13,3)) + │ ├── rights: (length: 0) + │ ├── lparen_loc: (13,0)-(13,1) = "(" + │ ├── rparen_loc: (13,3)-(13,4) = ")" + │ ├── operator_loc: (13,5)-(13,6) = "=" + │ └── value: + │ @ LocalVariableReadNode (location: (13,7)-(13,10)) + │ ├── name: :foo + │ └── depth: 0 + ├── @ MultiWriteNode (location: (14,0)-(14,23)) + │ ├── lefts: (length: 2) + │ │ ├── @ CallTargetNode (location: (14,1)-(14,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ LocalVariableReadNode (location: (14,1)-(14,2)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── call_operator_loc: (14,2)-(14,3) = "." + │ │ │ ├── name: :foo= + │ │ │ └── message_loc: (14,3)-(14,6) = "foo" + │ │ └── @ CallTargetNode (location: (14,8)-(14,13)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ LocalVariableReadNode (location: (14,8)-(14,9)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── call_operator_loc: (14,9)-(14,10) = "." + │ │ ├── name: :bar= + │ │ └── message_loc: (14,10)-(14,13) = "bar" + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (14,0)-(14,1) = "(" + │ ├── rparen_loc: (14,13)-(14,14) = ")" + │ ├── operator_loc: (14,15)-(14,16) = "=" + │ └── value: + │ @ ArrayNode (location: (14,17)-(14,23)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (14,18)-(14,19)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (14,21)-(14,22)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (14,17)-(14,18) = "[" + │ └── closing_loc: (14,22)-(14,23) = "]" + ├── @ MultiWriteNode (location: (15,0)-(15,24)) + │ ├── lefts: (length: 2) + │ │ ├── @ IndexTargetNode (location: (15,1)-(15,8)) + │ │ │ ├── flags: attribute_write + │ │ │ ├── receiver: + │ │ │ │ @ LocalVariableReadNode (location: (15,1)-(15,2)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── opening_loc: (15,2)-(15,3) = "[" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (15,3)-(15,7)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ SplatNode (location: (15,3)-(15,7)) + │ │ │ │ ├── operator_loc: (15,3)-(15,4) = "*" + │ │ │ │ └── expression: + │ │ │ │ @ LocalVariableReadNode (location: (15,4)-(15,7)) + │ │ │ │ ├── name: :foo + │ │ │ │ └── depth: 0 + │ │ │ ├── closing_loc: (15,7)-(15,8) = "]" + │ │ │ └── block: ∅ + │ │ └── @ IndexTargetNode (location: (15,10)-(15,14)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ LocalVariableReadNode (location: (15,10)-(15,11)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── opening_loc: (15,11)-(15,12) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (15,12)-(15,13)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (15,12)-(15,13)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: (15,13)-(15,14) = "]" + │ │ └── block: ∅ + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (15,0)-(15,1) = "(" + │ ├── rparen_loc: (15,14)-(15,15) = ")" + │ ├── operator_loc: (15,16)-(15,17) = "=" + │ └── value: + │ @ ArrayNode (location: (15,18)-(15,24)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (15,19)-(15,20)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (15,22)-(15,23)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (15,18)-(15,19) = "[" + │ └── closing_loc: (15,23)-(15,24) = "]" + ├── @ MultiWriteNode (location: (16,0)-(16,21)) + │ ├── lefts: (length: 2) + │ │ ├── @ IndexTargetNode (location: (16,1)-(16,5)) + │ │ │ ├── flags: attribute_write + │ │ │ ├── receiver: + │ │ │ │ @ LocalVariableReadNode (location: (16,1)-(16,2)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── opening_loc: (16,2)-(16,3) = "[" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (16,3)-(16,4)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (16,3)-(16,4)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 0 + │ │ │ ├── closing_loc: (16,4)-(16,5) = "]" + │ │ │ └── block: ∅ + │ │ └── @ IndexTargetNode (location: (16,7)-(16,11)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ LocalVariableReadNode (location: (16,7)-(16,8)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── opening_loc: (16,8)-(16,9) = "[" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (16,9)-(16,10)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (16,9)-(16,10)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: (16,10)-(16,11) = "]" + │ │ └── block: ∅ + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (16,0)-(16,1) = "(" + │ ├── rparen_loc: (16,11)-(16,12) = ")" + │ ├── operator_loc: (16,13)-(16,14) = "=" + │ └── value: + │ @ ArrayNode (location: (16,15)-(16,21)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (16,16)-(16,17)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (16,19)-(16,20)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (16,15)-(16,16) = "[" + │ └── closing_loc: (16,20)-(16,21) = "]" + ├── @ MultiWriteNode (location: (17,0)-(17,12)) + │ ├── lefts: (length: 0) + │ ├── rest: + │ │ @ SplatNode (location: (17,1)-(17,7)) + │ │ ├── operator_loc: (17,1)-(17,2) = "*" + │ │ └── expression: + │ │ @ CallTargetNode (location: (17,2)-(17,7)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ LocalVariableReadNode (location: (17,2)-(17,3)) + │ │ │ ├── name: :c + │ │ │ └── depth: 0 + │ │ ├── call_operator_loc: (17,3)-(17,4) = "." + │ │ ├── name: :foo= + │ │ └── message_loc: (17,4)-(17,7) = "foo" + │ ├── rights: (length: 0) + │ ├── lparen_loc: (17,0)-(17,1) = "(" + │ ├── rparen_loc: (17,7)-(17,8) = ")" + │ ├── operator_loc: (17,9)-(17,10) = "=" + │ └── value: + │ @ IntegerNode (location: (17,11)-(17,12)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ ConstantPathWriteNode (location: (18,0)-(18,13)) + │ ├── target: + │ │ @ ConstantPathNode (location: (18,0)-(18,5)) + │ │ ├── parent: ∅ + │ │ ├── name: :Foo + │ │ ├── delimiter_loc: (18,0)-(18,2) = "::" + │ │ └── name_loc: (18,2)-(18,5) = "Foo" + │ ├── operator_loc: (18,6)-(18,7) = "=" + │ └── value: + │ @ ConstantPathNode (location: (18,8)-(18,13)) + │ ├── parent: ∅ + │ ├── name: :Bar + │ ├── delimiter_loc: (18,8)-(18,10) = "::" + │ └── name_loc: (18,10)-(18,13) = "Bar" + ├── @ ClassVariableWriteNode (location: (19,0)-(19,7)) + │ ├── name: :@@a + │ ├── name_loc: (19,0)-(19,3) = "@@a" + │ ├── value: + │ │ @ IntegerNode (location: (19,6)-(19,7)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (19,4)-(19,5) = "=" + ├── @ InstanceVariableWriteNode (location: (20,0)-(20,6)) + │ ├── name: :@a + │ ├── name_loc: (20,0)-(20,2) = "@a" + │ ├── value: + │ │ @ IntegerNode (location: (20,5)-(20,6)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (20,3)-(20,4) = "=" + ├── @ ConstantWriteNode (location: (21,0)-(21,9)) + │ ├── name: :CONST + │ ├── name_loc: (21,0)-(21,5) = "CONST" + │ ├── value: + │ │ @ IntegerNode (location: (21,8)-(21,9)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (21,6)-(21,7) = "=" + ├── @ ConstantPathWriteNode (location: (22,0)-(22,23)) + │ ├── target: + │ │ @ ConstantPathNode (location: (22,0)-(22,19)) + │ │ ├── parent: + │ │ │ @ ConstantPathNode (location: (22,0)-(22,12)) + │ │ │ ├── parent: + │ │ │ │ @ ConstantReadNode (location: (22,0)-(22,4)) + │ │ │ │ └── name: :Name + │ │ │ ├── name: :Spaced + │ │ │ ├── delimiter_loc: (22,4)-(22,6) = "::" + │ │ │ └── name_loc: (22,6)-(22,12) = "Spaced" + │ │ ├── name: :CONST + │ │ ├── delimiter_loc: (22,12)-(22,14) = "::" + │ │ └── name_loc: (22,14)-(22,19) = "CONST" + │ ├── operator_loc: (22,20)-(22,21) = "=" + │ └── value: + │ @ IntegerNode (location: (22,22)-(22,23)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ LocalVariableWriteNode (location: (23,0)-(23,16)) + │ ├── name: :a + │ ├── depth: 0 + │ ├── name_loc: (23,0)-(23,1) = "a" + │ ├── value: + │ │ @ ParenthesesNode (location: (23,4)-(23,16)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (23,5)-(23,15)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ MultiWriteNode (location: (23,5)-(23,15)) + │ │ │ ├── lefts: (length: 2) + │ │ │ │ ├── @ LocalVariableTargetNode (location: (23,6)-(23,7)) + │ │ │ │ │ ├── name: :b + │ │ │ │ │ └── depth: 0 + │ │ │ │ └── @ LocalVariableTargetNode (location: (23,9)-(23,10)) + │ │ │ │ ├── name: :c + │ │ │ │ └── depth: 0 + │ │ │ ├── rest: ∅ + │ │ │ ├── rights: (length: 0) + │ │ │ ├── lparen_loc: (23,5)-(23,6) = "(" + │ │ │ ├── rparen_loc: (23,10)-(23,11) = ")" + │ │ │ ├── operator_loc: (23,12)-(23,13) = "=" + │ │ │ └── value: + │ │ │ @ IntegerNode (location: (23,14)-(23,15)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── opening_loc: (23,4)-(23,5) = "(" + │ │ └── closing_loc: (23,15)-(23,16) = ")" + │ └── operator_loc: (23,2)-(23,3) = "=" + ├── @ LocalVariableWriteNode (location: (24,0)-(24,5)) + │ ├── name: :a + │ ├── depth: 0 + │ ├── name_loc: (24,0)-(24,1) = "a" + │ ├── value: + │ │ @ IntegerNode (location: (24,4)-(24,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (24,2)-(24,3) = "=" + ├── @ LocalVariableWriteNode (location: (25,0)-(25,11)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (25,0)-(25,3) = "foo" + │ ├── value: + │ │ @ CallNode (location: (25,6)-(25,11)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (25,6)-(25,9) = "foo" + │ │ ├── opening_loc: (25,9)-(25,10) = "(" + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: (25,10)-(25,11) = ")" + │ │ └── block: ∅ + │ └── operator_loc: (25,4)-(25,5) = "=" + ├── @ CallNode (location: (26,0)-(26,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (26,0)-(26,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: (26,3)-(26,4) = "." + │ ├── name: :[]= + │ ├── message_loc: (26,4)-(26,7) = "[]=" + │ ├── opening_loc: (26,7)-(26,8) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (26,8)-(26,9) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (27,0)-(27,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (27,0)-(27,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: (27,3)-(27,4) = "." + │ ├── name: :[]= + │ ├── message_loc: (27,4)-(27,7) = "[]=" + │ ├── opening_loc: (27,7)-(27,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (27,8)-(27,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ IntegerNode (location: (27,8)-(27,9)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (27,11)-(27,12)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── closing_loc: (27,12)-(27,13) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (28,0)-(28,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (28,0)-(28,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: (28,3)-(28,4) = "." + │ ├── name: :[]= + │ ├── message_loc: (28,4)-(28,7) = "[]=" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (28,7)-(28,11)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ TrueNode (location: (28,7)-(28,11)) + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (29,0)-(29,19)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (29,0)-(29,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (29,3)-(29,11) = "[*index]" + │ ├── opening_loc: (29,3)-(29,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (29,4)-(29,19)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ SplatNode (location: (29,4)-(29,10)) + │ │ │ ├── operator_loc: (29,4)-(29,5) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (29,5)-(29,10)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :index + │ │ │ ├── message_loc: (29,5)-(29,10) = "index" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (29,14)-(29,19)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :value + │ │ ├── message_loc: (29,14)-(29,19) = "value" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (29,10)-(29,11) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (30,0)-(30,17)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (30,0)-(30,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (30,3)-(30,9) = "[1..2]" + │ ├── opening_loc: (30,3)-(30,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (30,4)-(30,17)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ RangeNode (location: (30,4)-(30,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── left: + │ │ │ │ @ IntegerNode (location: (30,4)-(30,5)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── right: + │ │ │ │ @ IntegerNode (location: (30,7)-(30,8)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ └── operator_loc: (30,5)-(30,7) = ".." + │ │ └── @ CallNode (location: (30,12)-(30,17)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :value + │ │ ├── message_loc: (30,12)-(30,17) = "value" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (30,8)-(30,9) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (31,0)-(31,9)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (31,0)-(31,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (31,3)-(31,5) = "[]" + │ ├── opening_loc: (31,3)-(31,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (31,8)-(31,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (31,8)-(31,9)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: (31,4)-(31,5) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (32,0)-(32,17)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (32,0)-(32,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (32,3)-(32,9) = "[a, b]" + │ ├── opening_loc: (32,3)-(32,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (32,4)-(32,17)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 3) + │ │ ├── @ LocalVariableReadNode (location: (32,4)-(32,5)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── @ LocalVariableReadNode (location: (32,7)-(32,8)) + │ │ │ ├── name: :b + │ │ │ └── depth: 0 + │ │ └── @ CallNode (location: (32,12)-(32,17)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :value + │ │ ├── message_loc: (32,12)-(32,17) = "value" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (32,8)-(32,9) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (33,0)-(33,18)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (33,0)-(33,3)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (33,3)-(33,10) = "[index]" + │ ├── opening_loc: (33,3)-(33,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (33,4)-(33,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (33,4)-(33,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :index + │ │ │ ├── message_loc: (33,4)-(33,9) = "index" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (33,13)-(33,18)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :value + │ │ ├── message_loc: (33,13)-(33,18) = "value" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (33,9)-(33,10) = "]" + │ └── block: ∅ + ├── @ LocalVariableWriteNode (location: (34,0)-(34,7)) + │ ├── name: :x + │ ├── depth: 0 + │ ├── name_loc: (34,0)-(34,1) = "x" + │ ├── value: + │ │ @ StringNode (location: (34,4)-(34,7)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (34,4)-(34,6) = "%(" + │ │ ├── content_loc: (34,6)-(34,6) = "" + │ │ ├── closing_loc: (34,6)-(34,7) = ")" + │ │ └── unescaped: "" + │ └── operator_loc: (34,2)-(34,3) = "=" + ├── @ CallNode (location: (35,0)-(35,7)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (35,0)-(35,1)) + │ │ ├── name: :x + │ │ └── depth: 0 + │ ├── call_operator_loc: (35,1)-(35,2) = "." + │ ├── name: :x= + │ ├── message_loc: (35,2)-(35,3) = "x" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (35,4)-(35,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (35,4)-(35,7)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (35,4)-(35,6) = "%(" + │ │ ├── content_loc: (35,6)-(35,6) = "" + │ │ ├── closing_loc: (35,6)-(35,7) = ")" + │ │ └── unescaped: "" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (36,0)-(36,12)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (36,0)-(36,1)) + │ │ ├── name: :x + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (36,1)-(36,6) = "[%()]" + │ ├── opening_loc: (36,1)-(36,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (36,2)-(36,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ StringNode (location: (36,2)-(36,5)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (36,2)-(36,4) = "%(" + │ │ │ ├── content_loc: (36,4)-(36,4) = "" + │ │ │ ├── closing_loc: (36,4)-(36,5) = ")" + │ │ │ └── unescaped: "" + │ │ └── @ CallNode (location: (36,9)-(36,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (36,9)-(36,12) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (36,5)-(36,6) = "]" + │ └── block: ∅ + ├── @ IndexOrWriteNode (location: (37,0)-(37,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (37,0)-(37,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (37,1)-(37,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (37,2)-(37,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (37,2)-(37,5)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (37,2)-(37,4) = "%(" + │ │ ├── content_loc: (37,4)-(37,4) = "" + │ │ ├── closing_loc: (37,4)-(37,5) = ")" + │ │ └── unescaped: "" + │ ├── closing_loc: (37,5)-(37,6) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (37,7)-(37,10) = "||=" + │ └── value: + │ @ CallNode (location: (37,11)-(37,14)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (37,11)-(37,14) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ InstanceVariableOrWriteNode (location: (38,0)-(38,10)) + │ ├── name: :@a + │ ├── name_loc: (38,0)-(38,2) = "@a" + │ ├── operator_loc: (38,3)-(38,6) = "||=" + │ └── value: + │ @ StringNode (location: (38,7)-(38,10)) + │ ├── flags: ∅ + │ ├── opening_loc: (38,7)-(38,9) = "%(" + │ ├── content_loc: (38,9)-(38,9) = "" + │ ├── closing_loc: (38,9)-(38,10) = ")" + │ └── unescaped: "" + ├── @ LocalVariableWriteNode (location: (39,0)-(39,14)) + │ ├── name: :x + │ ├── depth: 0 + │ ├── name_loc: (39,0)-(39,1) = "x" + │ ├── value: + │ │ @ InterpolatedStringNode (location: (39,4)-(39,14)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (39,4)-(39,14) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (40,0)-(40,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (40,0)-(40,2) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (40,2)-(40,5)) + │ │ │ │ ├── opening_loc: (40,2)-(40,4) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (40,4)-(40,5) = "}" + │ │ │ └── @ StringNode (location: (40,5)-(41,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (40,5)-(41,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (41,0)-(42,0) = "HEREDOC\n" + │ └── operator_loc: (39,2)-(39,3) = "=" + ├── @ CallNode (location: (42,0)-(42,14)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (42,0)-(42,1)) + │ │ ├── name: :x + │ │ └── depth: 0 + │ ├── call_operator_loc: (42,1)-(42,2) = "." + │ ├── name: :x= + │ ├── message_loc: (42,2)-(42,3) = "x" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (42,4)-(42,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (42,4)-(42,14)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (42,4)-(42,14) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (43,0)-(43,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (43,0)-(43,2) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (43,2)-(43,5)) + │ │ │ │ ├── opening_loc: (43,2)-(43,4) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (43,4)-(43,5) = "}" + │ │ │ └── @ StringNode (location: (43,5)-(44,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (43,5)-(44,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (44,0)-(45,0) = "HEREDOC\n" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (45,0)-(45,16)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (45,0)-(45,1)) + │ │ ├── name: :x + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :[]= + │ ├── message_loc: (45,1)-(45,3) = "[]" + │ ├── opening_loc: (45,1)-(45,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (45,6)-(45,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (45,6)-(45,16)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (45,6)-(45,16) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (46,0)-(46,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (46,0)-(46,2) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (46,2)-(46,5)) + │ │ │ │ ├── opening_loc: (46,2)-(46,4) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (46,4)-(46,5) = "}" + │ │ │ └── @ StringNode (location: (46,5)-(47,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (46,5)-(47,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (47,0)-(48,0) = "HEREDOC\n" + │ ├── closing_loc: (45,2)-(45,3) = "]" + │ └── block: ∅ + ├── @ IndexOrWriteNode (location: (48,0)-(48,21)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (48,0)-(48,1)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── opening_loc: (48,1)-(48,2) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (48,2)-(48,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (48,2)-(48,12)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (48,2)-(48,12) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (49,0)-(49,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (49,0)-(49,2) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (49,2)-(49,5)) + │ │ │ │ ├── opening_loc: (49,2)-(49,4) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (49,4)-(49,5) = "}" + │ │ │ └── @ StringNode (location: (49,5)-(50,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (49,5)-(50,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (50,0)-(51,0) = "HEREDOC\n" + │ ├── closing_loc: (48,12)-(48,13) = "]" + │ ├── block: ∅ + │ ├── operator_loc: (48,14)-(48,17) = "||=" + │ └── value: + │ @ CallNode (location: (48,18)-(48,21)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (48,18)-(48,21) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ InstanceVariableOrWriteNode (location: (51,0)-(51,17)) + ├── name: :@a + ├── name_loc: (51,0)-(51,2) = "@a" + ├── operator_loc: (51,3)-(51,6) = "||=" + └── value: + @ InterpolatedStringNode (location: (51,7)-(51,17)) + ├── flags: ∅ + ├── opening_loc: (51,7)-(51,17) = "<<-HEREDOC" + ├── parts: (length: 3) + │ ├── @ StringNode (location: (52,0)-(52,2)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (52,0)-(52,2) = " " + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: " " + │ ├── @ EmbeddedStatementsNode (location: (52,2)-(52,5)) + │ │ ├── opening_loc: (52,2)-(52,4) = "\#{" + │ │ ├── statements: ∅ + │ │ └── closing_loc: (52,4)-(52,5) = "}" + │ └── @ StringNode (location: (52,5)-(53,0)) + │ ├── flags: frozen + │ ├── opening_loc: ∅ + │ ├── content_loc: (52,5)-(53,0) = "\n" + │ ├── closing_loc: ∅ + │ └── unescaped: "\n" + └── closing_loc: (53,0)-(54,0) = "HEREDOC\n" diff --git a/test/prism/snapshots/unparser/corpus/literal/block.txt b/test/prism/snapshots/unparser/corpus/literal/block.txt new file mode 100644 index 0000000000..b4c86d0b04 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/block.txt @@ -0,0 +1,1402 @@ +@ ProgramNode (location: (1,0)-(96,1)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(96,1)) + └── body: (length: 30) + ├── @ CallNode (location: (1,0)-(2,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (1,4)-(2,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (1,4)-(1,5) = "{" + │ └── closing_loc: (2,0)-(2,1) = "}" + ├── @ CallNode (location: (3,0)-(4,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (3,0)-(3,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (3,4)-(4,1)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (3,6)-(3,9)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (3,7)-(3,8)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (3,7)-(3,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (3,6)-(3,7) = "|" + │ │ └── closing_loc: (3,8)-(3,9) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (3,4)-(3,5) = "{" + │ └── closing_loc: (4,0)-(4,1) = "}" + ├── @ CallNode (location: (5,0)-(6,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (5,0)-(5,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (5,4)-(6,1)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (5,6)-(5,10)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (5,7)-(5,9)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (5,7)-(5,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: + │ │ │ │ @ ImplicitRestNode (location: (5,8)-(5,9)) + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (5,6)-(5,7) = "|" + │ │ └── closing_loc: (5,9)-(5,10) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (5,4)-(5,5) = "{" + │ └── closing_loc: (6,0)-(6,1) = "}" + ├── @ CallNode (location: (7,0)-(8,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (7,0)-(7,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (7,4)-(8,1)) + │ ├── locals: [:a, :x] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (7,6)-(7,13)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (7,7)-(7,9)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (7,7)-(7,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: + │ │ │ │ @ ImplicitRestNode (location: (7,8)-(7,9)) + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 1) + │ │ │ └── @ BlockLocalVariableNode (location: (7,11)-(7,12)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :x + │ │ ├── opening_loc: (7,6)-(7,7) = "|" + │ │ └── closing_loc: (7,12)-(7,13) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (7,4)-(7,5) = "{" + │ └── closing_loc: (8,0)-(8,1) = "}" + ├── @ CallNode (location: (9,0)-(10,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (9,0)-(9,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (9,4)-(10,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (9,6)-(9,12)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (9,7)-(9,11)) + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ RequiredParameterNode (location: (9,7)-(9,8)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :a + │ │ │ │ └── @ RequiredParameterNode (location: (9,10)-(9,11)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :b + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (9,6)-(9,7) = "|" + │ │ └── closing_loc: (9,11)-(9,12) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (9,4)-(9,5) = "{" + │ └── closing_loc: (10,0)-(10,1) = "}" + ├── @ CallNode (location: (11,0)-(13,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (11,0)-(11,3) = "foo" + │ ├── opening_loc: (11,3)-(11,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (11,4)-(11,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (11,4)-(11,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: (11,5)-(11,6) = ")" + │ └── block: + │ @ BlockNode (location: (11,7)-(13,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (12,2)-(12,5)) + │ │ └── body: (length: 1) + │ │ └── @ NilNode (location: (12,2)-(12,5)) + │ ├── opening_loc: (11,7)-(11,8) = "{" + │ └── closing_loc: (13,0)-(13,1) = "}" + ├── @ CallNode (location: (14,0)-(16,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (14,0)-(14,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (14,4)-(16,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (14,6)-(14,13)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (14,7)-(14,12)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (14,7)-(14,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: + │ │ │ │ @ RestParameterNode (location: (14,10)-(14,12)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── name_loc: (14,11)-(14,12) = "b" + │ │ │ │ └── operator_loc: (14,10)-(14,11) = "*" + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (14,6)-(14,7) = "|" + │ │ └── closing_loc: (14,12)-(14,13) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (15,2)-(15,5)) + │ │ └── body: (length: 1) + │ │ └── @ NilNode (location: (15,2)-(15,5)) + │ ├── opening_loc: (14,4)-(14,5) = "{" + │ └── closing_loc: (16,0)-(16,1) = "}" + ├── @ CallNode (location: (17,0)-(19,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (17,0)-(17,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (17,4)-(19,1)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (17,6)-(17,12)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (17,7)-(17,11)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (17,7)-(17,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: + │ │ │ │ @ RestParameterNode (location: (17,10)-(17,11)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: ∅ + │ │ │ │ ├── name_loc: ∅ + │ │ │ │ └── operator_loc: (17,10)-(17,11) = "*" + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (17,6)-(17,7) = "|" + │ │ └── closing_loc: (17,11)-(17,12) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (18,2)-(18,5)) + │ │ └── body: (length: 1) + │ │ └── @ NilNode (location: (18,2)-(18,5)) + │ ├── opening_loc: (17,4)-(17,5) = "{" + │ └── closing_loc: (19,0)-(19,1) = "}" + ├── @ CallNode (location: (20,0)-(22,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (20,0)-(20,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (20,4)-(22,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (21,2)-(21,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (21,2)-(21,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (21,2)-(21,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (20,4)-(20,5) = "{" + │ └── closing_loc: (22,0)-(22,1) = "}" + ├── @ CallNode (location: (23,0)-(25,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (23,0)-(23,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (23,0)-(23,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (23,3)-(23,4) = "." + │ ├── name: :bar + │ ├── message_loc: (23,4)-(23,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (23,8)-(25,1)) + │ ├── locals: [:a, :b, :c] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (23,10)-(23,21)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (23,11)-(23,20)) + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ MultiTargetNode (location: (23,11)-(23,17)) + │ │ │ │ │ ├── lefts: (length: 2) + │ │ │ │ │ │ ├── @ RequiredParameterNode (location: (23,12)-(23,13)) + │ │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ │ └── name: :a + │ │ │ │ │ │ └── @ RequiredParameterNode (location: (23,15)-(23,16)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── name: :b + │ │ │ │ │ ├── rest: ∅ + │ │ │ │ │ ├── rights: (length: 0) + │ │ │ │ │ ├── lparen_loc: (23,11)-(23,12) = "(" + │ │ │ │ │ └── rparen_loc: (23,16)-(23,17) = ")" + │ │ │ │ └── @ RequiredParameterNode (location: (23,19)-(23,20)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :c + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (23,10)-(23,11) = "|" + │ │ └── closing_loc: (23,20)-(23,21) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (24,2)-(24,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (24,2)-(24,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (24,2)-(24,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (23,8)-(23,9) = "{" + │ └── closing_loc: (25,0)-(25,1) = "}" + ├── @ CallNode (location: (26,0)-(27,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (26,0)-(26,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (26,0)-(26,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (26,3)-(26,4) = "." + │ ├── name: :bar + │ ├── message_loc: (26,4)-(26,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (26,8)-(27,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (26,10)-(26,17)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (26,11)-(26,13)) + │ │ │ ├── requireds: (length: 0) + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: + │ │ │ │ @ RestParameterNode (location: (26,11)-(26,13)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── name_loc: (26,12)-(26,13) = "a" + │ │ │ │ └── operator_loc: (26,11)-(26,12) = "*" + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 1) + │ │ │ └── @ BlockLocalVariableNode (location: (26,15)-(26,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :b + │ │ ├── opening_loc: (26,10)-(26,11) = "|" + │ │ └── closing_loc: (26,16)-(26,17) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (26,8)-(26,9) = "{" + │ └── closing_loc: (27,0)-(27,1) = "}" + ├── @ CallNode (location: (28,0)-(29,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (28,0)-(28,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (28,0)-(28,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (28,3)-(28,4) = "." + │ ├── name: :bar + │ ├── message_loc: (28,4)-(28,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (28,8)-(29,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (28,10)-(28,16)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (28,11)-(28,12)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (28,11)-(28,12)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 1) + │ │ │ └── @ BlockLocalVariableNode (location: (28,14)-(28,15)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :b + │ │ ├── opening_loc: (28,10)-(28,11) = "|" + │ │ └── closing_loc: (28,15)-(28,16) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (28,8)-(28,9) = "{" + │ └── closing_loc: (29,0)-(29,1) = "}" + ├── @ CallNode (location: (30,0)-(31,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (30,0)-(30,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (30,0)-(30,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (30,3)-(30,4) = "." + │ ├── name: :bar + │ ├── message_loc: (30,4)-(30,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (30,8)-(31,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (30,10)-(30,18)) + │ │ ├── parameters: ∅ + │ │ ├── locals: (length: 2) + │ │ │ ├── @ BlockLocalVariableNode (location: (30,13)-(30,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ └── @ BlockLocalVariableNode (location: (30,16)-(30,17)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :b + │ │ ├── opening_loc: (30,10)-(30,11) = "|" + │ │ └── closing_loc: (30,17)-(30,18) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (30,8)-(30,9) = "{" + │ └── closing_loc: (31,0)-(31,1) = "}" + ├── @ CallNode (location: (32,0)-(34,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (32,0)-(32,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (32,0)-(32,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (32,3)-(32,4) = "." + │ ├── name: :bar + │ ├── message_loc: (32,4)-(32,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (32,8)-(34,1)) + │ ├── locals: [] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (32,10)-(32,13)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (32,11)-(32,12)) + │ │ │ ├── requireds: (length: 0) + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: + │ │ │ │ @ RestParameterNode (location: (32,11)-(32,12)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: ∅ + │ │ │ │ ├── name_loc: ∅ + │ │ │ │ └── operator_loc: (32,11)-(32,12) = "*" + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (32,10)-(32,11) = "|" + │ │ └── closing_loc: (32,12)-(32,13) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (33,2)-(33,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (33,2)-(33,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (33,2)-(33,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (32,8)-(32,9) = "{" + │ └── closing_loc: (34,0)-(34,1) = "}" + ├── @ CallNode (location: (35,0)-(37,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (35,0)-(35,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (35,0)-(35,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (35,3)-(35,4) = "." + │ ├── name: :bar + │ ├── message_loc: (35,4)-(35,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (35,8)-(37,1)) + │ ├── locals: [] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (35,10)-(35,15)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (35,11)-(35,14)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ MultiTargetNode (location: (35,11)-(35,14)) + │ │ │ │ ├── lefts: (length: 0) + │ │ │ │ ├── rest: + │ │ │ │ │ @ SplatNode (location: (35,12)-(35,13)) + │ │ │ │ │ ├── operator_loc: (35,12)-(35,13) = "*" + │ │ │ │ │ └── expression: ∅ + │ │ │ │ ├── rights: (length: 0) + │ │ │ │ ├── lparen_loc: (35,11)-(35,12) = "(" + │ │ │ │ └── rparen_loc: (35,13)-(35,14) = ")" + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (35,10)-(35,11) = "|" + │ │ └── closing_loc: (35,14)-(35,15) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (36,2)-(36,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (36,2)-(36,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (36,2)-(36,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (35,8)-(35,9) = "{" + │ └── closing_loc: (37,0)-(37,1) = "}" + ├── @ CallNode (location: (38,0)-(40,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (38,0)-(38,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (38,0)-(38,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (38,3)-(38,4) = "." + │ ├── name: :bar + │ ├── message_loc: (38,4)-(38,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (38,8)-(40,1)) + │ ├── locals: [] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (38,10)-(38,17)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (38,11)-(38,16)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ MultiTargetNode (location: (38,11)-(38,16)) + │ │ │ │ ├── lefts: (length: 1) + │ │ │ │ │ └── @ MultiTargetNode (location: (38,12)-(38,15)) + │ │ │ │ │ ├── lefts: (length: 0) + │ │ │ │ │ ├── rest: + │ │ │ │ │ │ @ SplatNode (location: (38,13)-(38,14)) + │ │ │ │ │ │ ├── operator_loc: (38,13)-(38,14) = "*" + │ │ │ │ │ │ └── expression: ∅ + │ │ │ │ │ ├── rights: (length: 0) + │ │ │ │ │ ├── lparen_loc: (38,12)-(38,13) = "(" + │ │ │ │ │ └── rparen_loc: (38,14)-(38,15) = ")" + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── rights: (length: 0) + │ │ │ │ ├── lparen_loc: (38,11)-(38,12) = "(" + │ │ │ │ └── rparen_loc: (38,15)-(38,16) = ")" + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (38,10)-(38,11) = "|" + │ │ └── closing_loc: (38,16)-(38,17) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (39,2)-(39,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (39,2)-(39,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (39,2)-(39,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (38,8)-(38,9) = "{" + │ └── closing_loc: (40,0)-(40,1) = "}" + ├── @ CallNode (location: (41,0)-(43,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (41,0)-(41,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (41,0)-(41,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (41,3)-(41,4) = "." + │ ├── name: :bar + │ ├── message_loc: (41,4)-(41,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (41,8)-(43,1)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (41,10)-(41,20)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (41,11)-(41,19)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ MultiTargetNode (location: (41,11)-(41,19)) + │ │ │ │ ├── lefts: (length: 2) + │ │ │ │ │ ├── @ RequiredParameterNode (location: (41,12)-(41,13)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── name: :a + │ │ │ │ │ └── @ MultiTargetNode (location: (41,15)-(41,18)) + │ │ │ │ │ ├── lefts: (length: 0) + │ │ │ │ │ ├── rest: + │ │ │ │ │ │ @ SplatNode (location: (41,16)-(41,17)) + │ │ │ │ │ │ ├── operator_loc: (41,16)-(41,17) = "*" + │ │ │ │ │ │ └── expression: ∅ + │ │ │ │ │ ├── rights: (length: 0) + │ │ │ │ │ ├── lparen_loc: (41,15)-(41,16) = "(" + │ │ │ │ │ └── rparen_loc: (41,17)-(41,18) = ")" + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── rights: (length: 0) + │ │ │ │ ├── lparen_loc: (41,11)-(41,12) = "(" + │ │ │ │ └── rparen_loc: (41,18)-(41,19) = ")" + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (41,10)-(41,11) = "|" + │ │ └── closing_loc: (41,19)-(41,20) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (42,2)-(42,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (42,2)-(42,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (42,2)-(42,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (41,8)-(41,9) = "{" + │ └── closing_loc: (43,0)-(43,1) = "}" + ├── @ CallNode (location: (44,0)-(46,1)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (44,0)-(44,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (44,0)-(44,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (44,3)-(44,4) = "." + │ ├── name: :bar + │ ├── message_loc: (44,4)-(44,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (44,8)-(46,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (44,10)-(44,18)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (44,11)-(44,17)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ MultiTargetNode (location: (44,11)-(44,17)) + │ │ │ │ ├── lefts: (length: 2) + │ │ │ │ │ ├── @ RequiredParameterNode (location: (44,12)-(44,13)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── name: :a + │ │ │ │ │ └── @ RequiredParameterNode (location: (44,15)-(44,16)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :b + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── rights: (length: 0) + │ │ │ │ ├── lparen_loc: (44,11)-(44,12) = "(" + │ │ │ │ └── rparen_loc: (44,16)-(44,17) = ")" + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (44,10)-(44,11) = "|" + │ │ └── closing_loc: (44,17)-(44,18) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (45,2)-(45,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (45,2)-(45,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (45,2)-(45,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (44,8)-(44,9) = "{" + │ └── closing_loc: (46,0)-(46,1) = "}" + ├── @ CallNode (location: (47,0)-(48,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (47,0)-(48,1)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (47,0)-(47,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (47,0)-(47,3) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (47,3)-(47,4) = "." + │ │ ├── name: :bar + │ │ ├── message_loc: (47,4)-(47,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (47,8)-(48,1)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (47,8)-(47,9) = "{" + │ │ └── closing_loc: (48,0)-(48,1) = "}" + │ ├── call_operator_loc: (48,1)-(48,2) = "." + │ ├── name: :baz + │ ├── message_loc: (48,2)-(48,5) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (49,0)-(51,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (49,0)-(49,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (49,2)-(51,3)) + │ ├── locals: [:e] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (49,2)-(51,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (50,0)-(50,21)) + │ │ │ ├── keyword_loc: (50,0)-(50,6) = "rescue" + │ │ │ ├── exceptions: (length: 1) + │ │ │ │ └── @ ConstantReadNode (location: (50,7)-(50,16)) + │ │ │ │ └── name: :Exception + │ │ │ ├── operator_loc: (50,17)-(50,19) = "=>" + │ │ │ ├── reference: + │ │ │ │ @ LocalVariableTargetNode (location: (50,20)-(50,21)) + │ │ │ │ ├── name: :e + │ │ │ │ └── depth: 0 + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (51,0)-(51,3) = "end" + │ ├── opening_loc: (49,2)-(49,4) = "do" + │ └── closing_loc: (51,0)-(51,3) = "end" + ├── @ CallNode (location: (52,0)-(56,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (52,0)-(52,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (52,2)-(56,3)) + │ ├── locals: [:bar] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (52,2)-(56,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (53,2)-(53,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (53,2)-(53,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (53,2)-(53,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (54,0)-(55,5)) + │ │ │ ├── keyword_loc: (54,0)-(54,6) = "rescue" + │ │ │ ├── exceptions: (length: 1) + │ │ │ │ └── @ ConstantReadNode (location: (54,7)-(54,16)) + │ │ │ │ └── name: :Exception + │ │ │ ├── operator_loc: (54,17)-(54,19) = "=>" + │ │ │ ├── reference: + │ │ │ │ @ LocalVariableTargetNode (location: (54,20)-(54,23)) + │ │ │ │ ├── name: :bar + │ │ │ │ └── depth: 0 + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (55,2)-(55,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ LocalVariableReadNode (location: (55,2)-(55,5)) + │ │ │ │ ├── name: :bar + │ │ │ │ └── depth: 0 + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (56,0)-(56,3) = "end" + │ ├── opening_loc: (52,2)-(52,4) = "do" + │ └── closing_loc: (56,0)-(56,3) = "end" + ├── @ CallNode (location: (57,0)-(61,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (57,0)-(57,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (57,2)-(61,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (57,2)-(61,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (58,2)-(58,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (58,2)-(58,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (58,2)-(58,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (59,0)-(60,5)) + │ │ │ ├── keyword_loc: (59,0)-(59,6) = "rescue" + │ │ │ ├── exceptions: (length: 2) + │ │ │ │ ├── @ ConstantReadNode (location: (59,7)-(59,16)) + │ │ │ │ │ └── name: :SomeError + │ │ │ │ └── @ SplatNode (location: (59,18)-(59,22)) + │ │ │ │ ├── operator_loc: (59,18)-(59,19) = "*" + │ │ │ │ └── expression: + │ │ │ │ @ CallNode (location: (59,19)-(59,22)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (59,19)-(59,22) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (60,2)-(60,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (60,2)-(60,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (60,2)-(60,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (61,0)-(61,3) = "end" + │ ├── opening_loc: (57,2)-(57,4) = "do" + │ └── closing_loc: (61,0)-(61,3) = "end" + ├── @ CallNode (location: (62,0)-(66,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (62,0)-(62,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (62,2)-(66,3)) + │ ├── locals: [:exception] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (62,2)-(66,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (63,2)-(63,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (63,2)-(63,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (63,2)-(63,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (64,0)-(65,5)) + │ │ │ ├── keyword_loc: (64,0)-(64,6) = "rescue" + │ │ │ ├── exceptions: (length: 2) + │ │ │ │ ├── @ ConstantReadNode (location: (64,7)-(64,16)) + │ │ │ │ │ └── name: :SomeError + │ │ │ │ └── @ SplatNode (location: (64,18)-(64,22)) + │ │ │ │ ├── operator_loc: (64,18)-(64,19) = "*" + │ │ │ │ └── expression: + │ │ │ │ @ CallNode (location: (64,19)-(64,22)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (64,19)-(64,22) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── operator_loc: (64,23)-(64,25) = "=>" + │ │ │ ├── reference: + │ │ │ │ @ LocalVariableTargetNode (location: (64,26)-(64,35)) + │ │ │ │ ├── name: :exception + │ │ │ │ └── depth: 0 + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (65,2)-(65,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (65,2)-(65,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (65,2)-(65,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (66,0)-(66,3) = "end" + │ ├── opening_loc: (62,2)-(62,4) = "do" + │ └── closing_loc: (66,0)-(66,3) = "end" + ├── @ CallNode (location: (67,0)-(71,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (67,0)-(67,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (67,2)-(71,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (67,2)-(71,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (68,2)-(68,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (68,2)-(68,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (68,2)-(68,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (69,0)-(70,5)) + │ │ │ ├── keyword_loc: (69,0)-(69,6) = "rescue" + │ │ │ ├── exceptions: (length: 1) + │ │ │ │ └── @ SplatNode (location: (69,7)-(69,11)) + │ │ │ │ ├── operator_loc: (69,7)-(69,8) = "*" + │ │ │ │ └── expression: + │ │ │ │ @ CallNode (location: (69,8)-(69,11)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (69,8)-(69,11) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (70,2)-(70,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (70,2)-(70,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (70,2)-(70,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (71,0)-(71,3) = "end" + │ ├── opening_loc: (67,2)-(67,4) = "do" + │ └── closing_loc: (71,0)-(71,3) = "end" + ├── @ CallNode (location: (72,0)-(75,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (72,0)-(72,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (72,2)-(75,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (72,2)-(75,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (73,2)-(73,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (73,2)-(73,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (73,2)-(73,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (74,0)-(74,16)) + │ │ │ ├── keyword_loc: (74,0)-(74,6) = "rescue" + │ │ │ ├── exceptions: (length: 1) + │ │ │ │ └── @ ConstantReadNode (location: (74,7)-(74,16)) + │ │ │ │ └── name: :LoadError + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (75,0)-(75,3) = "end" + │ ├── opening_loc: (72,2)-(72,4) = "do" + │ └── closing_loc: (75,0)-(75,3) = "end" + ├── @ CallNode (location: (76,0)-(81,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (76,0)-(76,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (76,2)-(81,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (76,2)-(81,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (77,2)-(77,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (77,2)-(77,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (77,2)-(77,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (78,0)-(78,6)) + │ │ │ ├── keyword_loc: (78,0)-(78,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: + │ │ │ @ ElseNode (location: (79,0)-(81,3)) + │ │ │ ├── else_keyword_loc: (79,0)-(79,4) = "else" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (80,2)-(80,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (80,2)-(80,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (80,2)-(80,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (81,0)-(81,3) = "end" + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (81,0)-(81,3) = "end" + │ ├── opening_loc: (76,2)-(76,4) = "do" + │ └── closing_loc: (81,0)-(81,3) = "end" + ├── @ CallNode (location: (82,0)-(86,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (82,0)-(82,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (82,2)-(86,3)) + │ ├── locals: [:exception] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (82,2)-(86,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (83,2)-(83,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (83,2)-(83,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (83,2)-(83,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (84,0)-(85,5)) + │ │ │ ├── keyword_loc: (84,0)-(84,6) = "rescue" + │ │ │ ├── exceptions: (length: 1) + │ │ │ │ └── @ SplatNode (location: (84,7)-(84,11)) + │ │ │ │ ├── operator_loc: (84,7)-(84,8) = "*" + │ │ │ │ └── expression: + │ │ │ │ @ CallNode (location: (84,8)-(84,11)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (84,8)-(84,11) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── operator_loc: (84,12)-(84,14) = "=>" + │ │ │ ├── reference: + │ │ │ │ @ LocalVariableTargetNode (location: (84,15)-(84,24)) + │ │ │ │ ├── name: :exception + │ │ │ │ └── depth: 0 + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (85,2)-(85,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (85,2)-(85,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (85,2)-(85,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (86,0)-(86,3) = "end" + │ ├── opening_loc: (82,2)-(82,4) = "do" + │ └── closing_loc: (86,0)-(86,3) = "end" + ├── @ CallNode (location: (87,0)-(89,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (87,0)-(87,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (87,2)-(89,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (87,2)-(89,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (88,0)-(89,3)) + │ │ │ ├── ensure_keyword_loc: (88,0)-(88,6) = "ensure" + │ │ │ ├── statements: ∅ + │ │ │ └── end_keyword_loc: (89,0)-(89,3) = "end" + │ │ └── end_keyword_loc: (89,0)-(89,3) = "end" + │ ├── opening_loc: (87,2)-(87,4) = "do" + │ └── closing_loc: (89,0)-(89,3) = "end" + ├── @ CallNode (location: (90,0)-(93,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :m + │ ├── message_loc: (90,0)-(90,1) = "m" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (90,2)-(93,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (90,2)-(93,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (91,0)-(91,6)) + │ │ │ ├── keyword_loc: (91,0)-(91,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (92,0)-(93,3)) + │ │ │ ├── ensure_keyword_loc: (92,0)-(92,6) = "ensure" + │ │ │ ├── statements: ∅ + │ │ │ └── end_keyword_loc: (93,0)-(93,3) = "end" + │ │ └── end_keyword_loc: (93,0)-(93,3) = "end" + │ ├── opening_loc: (90,2)-(90,4) = "do" + │ └── closing_loc: (93,0)-(93,3) = "end" + └── @ CallNode (location: (94,0)-(96,1)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :bar + ├── message_loc: (94,0)-(94,3) = "bar" + ├── opening_loc: ∅ + ├── arguments: ∅ + ├── closing_loc: ∅ + └── block: + @ BlockNode (location: (94,4)-(96,1)) + ├── locals: [:_1, :_2] + ├── parameters: + │ @ NumberedParametersNode (location: (94,4)-(96,1)) + │ └── maximum: 2 + ├── body: + │ @ StatementsNode (location: (95,2)-(95,9)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (95,2)-(95,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (95,2)-(95,4)) + │ │ ├── name: :_1 + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :+ + │ ├── message_loc: (95,5)-(95,6) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (95,7)-(95,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (95,7)-(95,9)) + │ │ ├── name: :_2 + │ │ └── depth: 0 + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── opening_loc: (94,4)-(94,5) = "{" + └── closing_loc: (96,0)-(96,1) = "}" diff --git a/test/prism/snapshots/unparser/corpus/literal/case.txt b/test/prism/snapshots/unparser/corpus/literal/case.txt new file mode 100644 index 0000000000..509caa55c8 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/case.txt @@ -0,0 +1,446 @@ +@ ProgramNode (location: (1,0)-(37,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(37,3)) + └── body: (length: 8) + ├── @ CaseNode (location: (1,0)-(6,3)) + │ ├── predicate: ∅ + │ ├── conditions: (length: 2) + │ │ ├── @ WhenNode (location: (2,0)-(3,5)) + │ │ │ ├── keyword_loc: (2,0)-(2,4) = "when" + │ │ │ ├── conditions: (length: 1) + │ │ │ │ └── @ CallNode (location: (2,5)-(2,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (2,5)-(2,8) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (3,2)-(3,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (3,2)-(3,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (3,2)-(3,5) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ WhenNode (location: (4,0)-(5,5)) + │ │ ├── keyword_loc: (4,0)-(4,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ CallNode (location: (4,5)-(4,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (4,5)-(4,8) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (5,2)-(5,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (5,2)-(5,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (5,2)-(5,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (1,0)-(1,4) = "case" + │ └── end_keyword_loc: (6,0)-(6,3) = "end" + ├── @ CaseNode (location: (7,0)-(11,3)) + │ ├── predicate: + │ │ @ CallNode (location: (7,5)-(7,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (7,5)-(7,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 2) + │ │ ├── @ WhenNode (location: (8,0)-(8,8)) + │ │ │ ├── keyword_loc: (8,0)-(8,4) = "when" + │ │ │ ├── conditions: (length: 1) + │ │ │ │ └── @ CallNode (location: (8,5)-(8,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (8,5)-(8,8) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ └── statements: ∅ + │ │ └── @ WhenNode (location: (9,0)-(10,5)) + │ │ ├── keyword_loc: (9,0)-(9,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ CallNode (location: (9,5)-(9,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (9,5)-(9,8) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (10,2)-(10,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (10,2)-(10,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (10,2)-(10,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (7,0)-(7,4) = "case" + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ CaseNode (location: (12,0)-(17,3)) + │ ├── predicate: + │ │ @ CallNode (location: (12,5)-(12,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (12,5)-(12,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 2) + │ │ ├── @ WhenNode (location: (13,0)-(14,5)) + │ │ │ ├── keyword_loc: (13,0)-(13,4) = "when" + │ │ │ ├── conditions: (length: 1) + │ │ │ │ └── @ CallNode (location: (13,5)-(13,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (13,5)-(13,8) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (14,2)-(14,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (14,2)-(14,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (14,2)-(14,5) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ WhenNode (location: (15,0)-(16,5)) + │ │ ├── keyword_loc: (15,0)-(15,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ CallNode (location: (15,5)-(15,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (15,5)-(15,8) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (16,2)-(16,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (16,2)-(16,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (16,2)-(16,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (12,0)-(12,4) = "case" + │ └── end_keyword_loc: (17,0)-(17,3) = "end" + ├── @ CaseNode (location: (18,0)-(21,3)) + │ ├── predicate: + │ │ @ CallNode (location: (18,5)-(18,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (18,5)-(18,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ WhenNode (location: (19,0)-(20,8)) + │ │ ├── keyword_loc: (19,0)-(19,4) = "when" + │ │ ├── conditions: (length: 2) + │ │ │ ├── @ CallNode (location: (19,5)-(19,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (19,5)-(19,8) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── @ CallNode (location: (19,10)-(19,13)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (19,10)-(19,13) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (20,2)-(20,8)) + │ │ └── body: (length: 1) + │ │ └── @ SymbolNode (location: (20,2)-(20,8)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (20,2)-(20,3) = ":" + │ │ ├── value_loc: (20,3)-(20,8) = "other" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "other" + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (18,0)-(18,4) = "case" + │ └── end_keyword_loc: (21,0)-(21,3) = "end" + ├── @ CaseNode (location: (22,0)-(25,3)) + │ ├── predicate: + │ │ @ CallNode (location: (22,5)-(22,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (22,5)-(22,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ WhenNode (location: (23,0)-(24,8)) + │ │ ├── keyword_loc: (23,0)-(23,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ SplatNode (location: (23,5)-(23,9)) + │ │ │ ├── operator_loc: (23,5)-(23,6) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (23,6)-(23,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (23,6)-(23,9) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (24,2)-(24,8)) + │ │ └── body: (length: 1) + │ │ └── @ SymbolNode (location: (24,2)-(24,8)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (24,2)-(24,3) = ":" + │ │ ├── value_loc: (24,3)-(24,8) = "value" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "value" + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (22,0)-(22,4) = "case" + │ └── end_keyword_loc: (25,0)-(25,3) = "end" + ├── @ CaseNode (location: (26,0)-(31,3)) + │ ├── predicate: + │ │ @ CallNode (location: (26,5)-(26,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (26,5)-(26,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ WhenNode (location: (27,0)-(28,5)) + │ │ ├── keyword_loc: (27,0)-(27,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ CallNode (location: (27,5)-(27,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (27,5)-(27,8) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (28,2)-(28,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (28,2)-(28,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (28,2)-(28,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: + │ │ @ ElseNode (location: (29,0)-(31,3)) + │ │ ├── else_keyword_loc: (29,0)-(29,4) = "else" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (30,2)-(30,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ SymbolNode (location: (30,2)-(30,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (30,2)-(30,3) = ":" + │ │ │ ├── value_loc: (30,3)-(30,6) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ └── end_keyword_loc: (31,0)-(31,3) = "end" + │ ├── case_keyword_loc: (26,0)-(26,4) = "case" + │ └── end_keyword_loc: (31,0)-(31,3) = "end" + ├── @ CaseNode (location: (32,0)-(34,3)) + │ ├── predicate: + │ │ @ CallNode (location: (32,5)-(32,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (32,5)-(32,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ WhenNode (location: (33,0)-(33,15)) + │ │ ├── keyword_loc: (33,0)-(33,4) = "when" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ SplatNode (location: (33,5)-(33,15)) + │ │ │ ├── operator_loc: (33,5)-(33,6) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (33,6)-(33,15)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (33,6)-(33,9)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (33,6)-(33,9) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :| + │ │ │ ├── message_loc: (33,10)-(33,11) = "|" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (33,12)-(33,15)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (33,12)-(33,15)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (33,12)-(33,15) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ └── statements: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (32,0)-(32,4) = "case" + │ └── end_keyword_loc: (34,0)-(34,3) = "end" + └── @ CaseNode (location: (35,0)-(37,3)) + ├── predicate: + │ @ CallNode (location: (35,5)-(35,8)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (35,5)-(35,8) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── conditions: (length: 1) + │ └── @ WhenNode (location: (36,0)-(36,15)) + │ ├── keyword_loc: (36,0)-(36,4) = "when" + │ ├── conditions: (length: 1) + │ │ └── @ SplatNode (location: (36,5)-(36,15)) + │ │ ├── operator_loc: (36,5)-(36,6) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (36,6)-(36,15)) + │ │ ├── flags: attribute_write + │ │ ├── receiver: + │ │ │ @ CallNode (location: (36,6)-(36,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (36,6)-(36,9) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (36,9)-(36,10) = "." + │ │ ├── name: :baz= + │ │ ├── message_loc: (36,10)-(36,13) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (36,14)-(36,15)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ IntegerNode (location: (36,14)-(36,15)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── then_keyword_loc: ∅ + │ └── statements: ∅ + ├── consequent: ∅ + ├── case_keyword_loc: (35,0)-(35,4) = "case" + └── end_keyword_loc: (37,0)-(37,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/class.txt b/test/prism/snapshots/unparser/corpus/literal/class.txt new file mode 100644 index 0000000000..5306888398 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/class.txt @@ -0,0 +1,226 @@ +@ ProgramNode (location: (1,0)-(35,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(35,3)) + └── body: (length: 10) + ├── @ ClassNode (location: (1,0)-(2,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (1,0)-(1,5) = "class" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (1,6)-(1,7)) + │ │ └── name: :A + │ ├── inheritance_operator_loc: ∅ + │ ├── superclass: ∅ + │ ├── body: ∅ + │ ├── end_keyword_loc: (2,0)-(2,3) = "end" + │ └── name: :A + ├── @ SingletonClassNode (location: (4,0)-(5,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (4,0)-(4,5) = "class" + │ ├── operator_loc: (4,6)-(4,8) = "<<" + │ ├── expression: + │ │ @ CallNode (location: (4,9)-(4,10)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (4,9)-(4,10) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ └── end_keyword_loc: (5,0)-(5,3) = "end" + ├── @ SingletonClassNode (location: (7,0)-(9,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (7,0)-(7,5) = "class" + │ ├── operator_loc: (7,6)-(7,8) = "<<" + │ ├── expression: + │ │ @ CallNode (location: (7,9)-(7,10)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (7,9)-(7,10) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (8,2)-(8,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (8,2)-(8,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (8,2)-(8,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── end_keyword_loc: (9,0)-(9,3) = "end" + ├── @ ClassNode (location: (11,0)-(12,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (11,0)-(11,5) = "class" + │ ├── constant_path: + │ │ @ ConstantPathNode (location: (11,6)-(11,10)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (11,6)-(11,7)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (11,7)-(11,9) = "::" + │ │ └── name_loc: (11,9)-(11,10) = "B" + │ ├── inheritance_operator_loc: ∅ + │ ├── superclass: ∅ + │ ├── body: ∅ + │ ├── end_keyword_loc: (12,0)-(12,3) = "end" + │ └── name: :B + ├── @ ClassNode (location: (14,0)-(15,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (14,0)-(14,5) = "class" + │ ├── constant_path: + │ │ @ ConstantPathNode (location: (14,6)-(14,13)) + │ │ ├── parent: + │ │ │ @ ConstantPathNode (location: (14,6)-(14,10)) + │ │ │ ├── parent: + │ │ │ │ @ ConstantReadNode (location: (14,6)-(14,7)) + │ │ │ │ └── name: :A + │ │ │ ├── name: :B + │ │ │ ├── delimiter_loc: (14,7)-(14,9) = "::" + │ │ │ └── name_loc: (14,9)-(14,10) = "B" + │ │ ├── name: :C + │ │ ├── delimiter_loc: (14,10)-(14,12) = "::" + │ │ └── name_loc: (14,12)-(14,13) = "C" + │ ├── inheritance_operator_loc: ∅ + │ ├── superclass: ∅ + │ ├── body: ∅ + │ ├── end_keyword_loc: (15,0)-(15,3) = "end" + │ └── name: :C + ├── @ ClassNode (location: (17,0)-(18,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (17,0)-(17,5) = "class" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (17,6)-(17,7)) + │ │ └── name: :A + │ ├── inheritance_operator_loc: (17,8)-(17,9) = "<" + │ ├── superclass: + │ │ @ ConstantReadNode (location: (17,10)-(17,11)) + │ │ └── name: :B + │ ├── body: ∅ + │ ├── end_keyword_loc: (18,0)-(18,3) = "end" + │ └── name: :A + ├── @ ClassNode (location: (20,0)-(21,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (20,0)-(20,5) = "class" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (20,6)-(20,7)) + │ │ └── name: :A + │ ├── inheritance_operator_loc: (20,8)-(20,9) = "<" + │ ├── superclass: + │ │ @ ConstantPathNode (location: (20,10)-(20,14)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (20,10)-(20,11)) + │ │ │ └── name: :B + │ │ ├── name: :C + │ │ ├── delimiter_loc: (20,11)-(20,13) = "::" + │ │ └── name_loc: (20,13)-(20,14) = "C" + │ ├── body: ∅ + │ ├── end_keyword_loc: (21,0)-(21,3) = "end" + │ └── name: :A + ├── @ ClassNode (location: (23,0)-(24,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (23,0)-(23,5) = "class" + │ ├── constant_path: + │ │ @ ConstantPathNode (location: (23,6)-(23,10)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (23,6)-(23,7)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (23,7)-(23,9) = "::" + │ │ └── name_loc: (23,9)-(23,10) = "B" + │ ├── inheritance_operator_loc: (23,11)-(23,12) = "<" + │ ├── superclass: + │ │ @ ConstantPathNode (location: (23,13)-(23,17)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (23,13)-(23,14)) + │ │ │ └── name: :C + │ │ ├── name: :D + │ │ ├── delimiter_loc: (23,14)-(23,16) = "::" + │ │ └── name_loc: (23,16)-(23,17) = "D" + │ ├── body: ∅ + │ ├── end_keyword_loc: (24,0)-(24,3) = "end" + │ └── name: :B + ├── @ ClassNode (location: (26,0)-(32,3)) + │ ├── locals: [] + │ ├── class_keyword_loc: (26,0)-(26,5) = "class" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (26,6)-(26,7)) + │ │ └── name: :A + │ ├── inheritance_operator_loc: ∅ + │ ├── superclass: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (27,2)-(31,5)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (27,2)-(27,16)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :include + │ │ │ ├── message_loc: (27,2)-(27,9) = "include" + │ │ │ ├── opening_loc: (27,9)-(27,10) = "(" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (27,10)-(27,15)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (27,10)-(27,15)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── receiver: + │ │ │ │ │ @ ConstantReadNode (location: (27,10)-(27,11)) + │ │ │ │ │ └── name: :B + │ │ │ │ ├── call_operator_loc: (27,11)-(27,12) = "." + │ │ │ │ ├── name: :new + │ │ │ │ ├── message_loc: (27,12)-(27,15) = "new" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: (27,15)-(27,16) = ")" + │ │ │ └── block: ∅ + │ │ └── @ DefNode (location: (29,2)-(31,5)) + │ │ ├── name: :foo + │ │ ├── name_loc: (29,6)-(29,9) = "foo" + │ │ ├── receiver: ∅ + │ │ ├── parameters: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (30,4)-(30,8)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ SymbolNode (location: (30,4)-(30,8)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (30,4)-(30,5) = ":" + │ │ │ ├── value_loc: (30,5)-(30,8) = "bar" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "bar" + │ │ ├── locals: [] + │ │ ├── def_keyword_loc: (29,2)-(29,5) = "def" + │ │ ├── operator_loc: ∅ + │ │ ├── lparen_loc: ∅ + │ │ ├── rparen_loc: ∅ + │ │ ├── equal_loc: ∅ + │ │ └── end_keyword_loc: (31,2)-(31,5) = "end" + │ ├── end_keyword_loc: (32,0)-(32,3) = "end" + │ └── name: :A + └── @ ClassNode (location: (34,0)-(35,3)) + ├── locals: [] + ├── class_keyword_loc: (34,0)-(34,5) = "class" + ├── constant_path: + │ @ ConstantPathNode (location: (34,6)-(34,9)) + │ ├── parent: ∅ + │ ├── name: :A + │ ├── delimiter_loc: (34,6)-(34,8) = "::" + │ └── name_loc: (34,8)-(34,9) = "A" + ├── inheritance_operator_loc: ∅ + ├── superclass: ∅ + ├── body: ∅ + ├── end_keyword_loc: (35,0)-(35,3) = "end" + └── name: :A diff --git a/test/prism/snapshots/unparser/corpus/literal/def.txt b/test/prism/snapshots/unparser/corpus/literal/def.txt new file mode 100644 index 0000000000..f3ef6c388e --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/def.txt @@ -0,0 +1,1204 @@ +@ ProgramNode (location: (1,0)-(134,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(134,3)) + └── body: (length: 30) + ├── @ DefNode (location: (1,0)-(9,3)) + │ ├── name: :foo + │ ├── name_loc: (1,4)-(1,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (1,0)-(9,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (2,2)-(2,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (2,2)-(2,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (2,2)-(2,3) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (3,0)-(4,3)) + │ │ │ ├── keyword_loc: (3,0)-(3,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (4,2)-(4,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (4,2)-(4,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (4,2)-(4,3) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: + │ │ │ @ ElseNode (location: (5,0)-(7,6)) + │ │ │ ├── else_keyword_loc: (5,0)-(5,4) = "else" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (6,2)-(6,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (6,2)-(6,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :c + │ │ │ │ ├── message_loc: (6,2)-(6,3) = "c" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (7,0)-(7,6) = "ensure" + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (7,0)-(9,3)) + │ │ │ ├── ensure_keyword_loc: (7,0)-(7,6) = "ensure" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (8,2)-(8,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (8,2)-(8,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :d + │ │ │ │ ├── message_loc: (8,2)-(8,3) = "d" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (9,0)-(9,3) = "end" + │ │ └── end_keyword_loc: (9,0)-(9,3) = "end" + │ ├── locals: [] + │ ├── def_keyword_loc: (1,0)-(1,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (9,0)-(9,3) = "end" + ├── @ DefNode (location: (11,0)-(19,3)) + │ ├── name: :foo + │ ├── name_loc: (11,4)-(11,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (11,0)-(19,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (12,2)-(12,12)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ RescueModifierNode (location: (12,2)-(12,12)) + │ │ │ ├── expression: + │ │ │ │ @ CallNode (location: (12,2)-(12,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (12,2)-(12,3) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── keyword_loc: (12,4)-(12,10) = "rescue" + │ │ │ └── rescue_expression: + │ │ │ @ CallNode (location: (12,11)-(12,12)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (12,11)-(12,12) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (13,0)-(14,3)) + │ │ │ ├── keyword_loc: (13,0)-(13,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (14,2)-(14,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (14,2)-(14,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (14,2)-(14,3) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: + │ │ │ @ ElseNode (location: (15,0)-(17,6)) + │ │ │ ├── else_keyword_loc: (15,0)-(15,4) = "else" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (16,2)-(16,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (16,2)-(16,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :c + │ │ │ │ ├── message_loc: (16,2)-(16,3) = "c" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (17,0)-(17,6) = "ensure" + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (17,0)-(19,3)) + │ │ │ ├── ensure_keyword_loc: (17,0)-(17,6) = "ensure" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (18,2)-(18,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (18,2)-(18,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :d + │ │ │ │ ├── message_loc: (18,2)-(18,3) = "d" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (19,0)-(19,3) = "end" + │ │ └── end_keyword_loc: (19,0)-(19,3) = "end" + │ ├── locals: [] + │ ├── def_keyword_loc: (11,0)-(11,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (19,0)-(19,3) = "end" + ├── @ DefNode (location: (21,0)-(22,3)) + │ ├── name: :foo + │ ├── name_loc: (21,4)-(21,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (21,8)-(21,18)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 2) + │ │ │ ├── @ RequiredKeywordParameterNode (location: (21,8)-(21,12)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ └── name_loc: (21,8)-(21,12) = "bar:" + │ │ │ └── @ RequiredKeywordParameterNode (location: (21,14)-(21,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ └── name_loc: (21,14)-(21,18) = "baz:" + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:bar, :baz] + │ ├── def_keyword_loc: (21,0)-(21,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (21,7)-(21,8) = "(" + │ ├── rparen_loc: (21,18)-(21,19) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (22,0)-(22,3) = "end" + ├── @ DefNode (location: (24,0)-(25,3)) + │ ├── name: :foo + │ ├── name_loc: (24,4)-(24,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (24,0)-(24,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (25,0)-(25,3) = "end" + ├── @ DefNode (location: (27,0)-(29,3)) + │ ├── name: :foo + │ ├── name_loc: (27,4)-(27,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (28,2)-(28,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (28,2)-(28,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (28,2)-(28,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (27,0)-(27,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (29,0)-(29,3) = "end" + ├── @ DefNode (location: (31,0)-(37,3)) + │ ├── name: :foo + │ ├── name_loc: (31,4)-(31,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (31,0)-(37,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (32,2)-(32,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (32,2)-(32,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (32,2)-(32,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (33,0)-(34,5)) + │ │ │ ├── keyword_loc: (33,0)-(33,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (34,2)-(34,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (34,2)-(34,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (34,2)-(34,5) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (35,0)-(37,3)) + │ │ │ ├── ensure_keyword_loc: (35,0)-(35,6) = "ensure" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (36,2)-(36,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (36,2)-(36,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (36,2)-(36,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (37,0)-(37,3) = "end" + │ │ └── end_keyword_loc: (37,0)-(37,3) = "end" + │ ├── locals: [] + │ ├── def_keyword_loc: (31,0)-(31,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (37,0)-(37,3) = "end" + ├── @ DefNode (location: (39,0)-(43,3)) + │ ├── name: :foo + │ ├── name_loc: (39,4)-(39,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (39,0)-(43,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (40,2)-(40,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (40,2)-(40,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (40,2)-(40,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: + │ │ │ @ EnsureNode (location: (41,0)-(43,3)) + │ │ │ ├── ensure_keyword_loc: (41,0)-(41,6) = "ensure" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (42,2)-(42,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (42,2)-(42,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (42,2)-(42,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── end_keyword_loc: (43,0)-(43,3) = "end" + │ │ └── end_keyword_loc: (43,0)-(43,3) = "end" + │ ├── locals: [] + │ ├── def_keyword_loc: (39,0)-(39,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (43,0)-(43,3) = "end" + ├── @ DefNode (location: (45,0)-(49,3)) + │ ├── name: :foo + │ ├── name_loc: (45,4)-(45,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (45,0)-(49,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (46,2)-(46,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (46,2)-(46,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (46,2)-(46,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (47,0)-(48,5)) + │ │ │ ├── keyword_loc: (47,0)-(47,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (48,2)-(48,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (48,2)-(48,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (48,2)-(48,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (49,0)-(49,3) = "end" + │ ├── locals: [] + │ ├── def_keyword_loc: (45,0)-(45,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (49,0)-(49,3) = "end" + ├── @ DefNode (location: (51,0)-(53,3)) + │ ├── name: :foo + │ ├── name_loc: (51,4)-(51,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (51,8)-(51,11)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (51,8)-(51,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :bar + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (52,2)-(52,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (52,2)-(52,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (51,0)-(51,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (51,7)-(51,8) = "(" + │ ├── rparen_loc: (51,11)-(51,12) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (53,0)-(53,3) = "end" + ├── @ DefNode (location: (55,0)-(57,3)) + │ ├── name: :foo + │ ├── name_loc: (55,4)-(55,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (55,8)-(55,16)) + │ │ ├── requireds: (length: 2) + │ │ │ ├── @ RequiredParameterNode (location: (55,8)-(55,11)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :bar + │ │ │ └── @ RequiredParameterNode (location: (55,13)-(55,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :baz + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (56,2)-(56,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (56,2)-(56,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar, :baz] + │ ├── def_keyword_loc: (55,0)-(55,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (55,7)-(55,8) = "(" + │ ├── rparen_loc: (55,16)-(55,17) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (57,0)-(57,3) = "end" + ├── @ DefNode (location: (59,0)-(61,3)) + │ ├── name: :foo + │ ├── name_loc: (59,4)-(59,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (59,8)-(59,16)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (59,8)-(59,16)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (59,8)-(59,11) = "bar" + │ │ │ ├── operator_loc: (59,12)-(59,13) = "=" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (59,14)-(59,16)) + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (59,14)-(59,15) = "(" + │ │ │ └── closing_loc: (59,15)-(59,16) = ")" + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (60,2)-(60,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (60,2)-(60,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (59,0)-(59,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (59,7)-(59,8) = "(" + │ ├── rparen_loc: (59,16)-(59,17) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (61,0)-(61,3) = "end" + ├── @ DefNode (location: (63,0)-(64,3)) + │ ├── name: :foo + │ ├── name_loc: (63,4)-(63,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (63,8)-(63,24)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (63,8)-(63,24)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (63,8)-(63,11) = "bar" + │ │ │ ├── operator_loc: (63,12)-(63,13) = "=" + │ │ │ └── value: + │ │ │ @ ParenthesesNode (location: (63,14)-(63,24)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (63,15)-(63,23)) + │ │ │ │ └── body: (length: 2) + │ │ │ │ ├── @ CallNode (location: (63,15)-(63,18)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :baz + │ │ │ │ │ ├── message_loc: (63,15)-(63,18) = "baz" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── @ NilNode (location: (63,20)-(63,23)) + │ │ │ ├── opening_loc: (63,14)-(63,15) = "(" + │ │ │ └── closing_loc: (63,23)-(63,24) = ")" + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (63,0)-(63,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (63,7)-(63,8) = "(" + │ ├── rparen_loc: (63,24)-(63,25) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (64,0)-(64,3) = "end" + ├── @ DefNode (location: (66,0)-(68,3)) + │ ├── name: :foo + │ ├── name_loc: (66,4)-(66,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (66,8)-(66,18)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (66,8)-(66,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (66,8)-(66,11) = "bar" + │ │ │ ├── operator_loc: (66,12)-(66,13) = "=" + │ │ │ └── value: + │ │ │ @ TrueNode (location: (66,14)-(66,18)) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (67,2)-(67,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (67,2)-(67,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (66,0)-(66,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (66,7)-(66,8) = "(" + │ ├── rparen_loc: (66,18)-(66,19) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (68,0)-(68,3) = "end" + ├── @ DefNode (location: (70,0)-(72,3)) + │ ├── name: :foo + │ ├── name_loc: (70,4)-(70,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (70,8)-(70,23)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (70,8)-(70,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :bar + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (70,13)-(70,23)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── name_loc: (70,13)-(70,16) = "baz" + │ │ │ ├── operator_loc: (70,17)-(70,18) = "=" + │ │ │ └── value: + │ │ │ @ TrueNode (location: (70,19)-(70,23)) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (71,2)-(71,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (71,2)-(71,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar, :baz] + │ ├── def_keyword_loc: (70,0)-(70,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (70,7)-(70,8) = "(" + │ ├── rparen_loc: (70,23)-(70,24) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (72,0)-(72,3) = "end" + ├── @ DefNode (location: (74,0)-(75,3)) + │ ├── name: :foo + │ ├── name_loc: (74,4)-(74,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (74,8)-(74,14)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (74,8)-(74,14)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (74,8)-(74,12) = "bar:" + │ │ │ └── value: + │ │ │ @ IntegerNode (location: (74,13)-(74,14)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (74,0)-(74,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (74,7)-(74,8) = "(" + │ ├── rparen_loc: (74,14)-(74,15) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (75,0)-(75,3) = "end" + ├── @ DefNode (location: (77,0)-(78,3)) + │ ├── name: :foo + │ ├── name_loc: (77,4)-(77,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (77,8)-(77,16)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (77,8)-(77,16)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (77,8)-(77,12) = "bar:" + │ │ │ └── value: + │ │ │ @ CallNode (location: (77,13)-(77,16)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (77,13)-(77,16) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (77,0)-(77,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (77,7)-(77,8) = "(" + │ ├── rparen_loc: (77,16)-(77,17) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (78,0)-(78,3) = "end" + ├── @ DefNode (location: (80,0)-(81,3)) + │ ├── name: :foo + │ ├── name_loc: (80,4)-(80,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (80,8)-(80,18)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 1) + │ │ │ └── @ OptionalKeywordParameterNode (location: (80,8)-(80,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (80,8)-(80,12) = "bar:" + │ │ │ └── value: + │ │ │ @ CallNode (location: (80,13)-(80,18)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (80,13)-(80,16) = "bar" + │ │ │ ├── opening_loc: (80,16)-(80,17) = "(" + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: (80,17)-(80,18) = ")" + │ │ │ └── block: ∅ + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (80,0)-(80,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (80,7)-(80,8) = "(" + │ ├── rparen_loc: (80,18)-(80,19) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (81,0)-(81,3) = "end" + ├── @ DefNode (location: (83,0)-(85,3)) + │ ├── name: :foo + │ ├── name_loc: (83,4)-(83,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (83,8)-(83,9)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (83,8)-(83,9)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (83,8)-(83,9) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (84,2)-(84,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (84,2)-(84,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (84,2)-(84,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (83,0)-(83,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (83,7)-(83,8) = "(" + │ ├── rparen_loc: (83,9)-(83,10) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (85,0)-(85,3) = "end" + ├── @ DefNode (location: (87,0)-(89,3)) + │ ├── name: :foo + │ ├── name_loc: (87,4)-(87,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (87,8)-(87,12)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (87,8)-(87,12)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── name_loc: (87,9)-(87,12) = "bar" + │ │ │ └── operator_loc: (87,8)-(87,9) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (88,2)-(88,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (88,2)-(88,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar] + │ ├── def_keyword_loc: (87,0)-(87,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (87,7)-(87,8) = "(" + │ ├── rparen_loc: (87,12)-(87,13) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (89,0)-(89,3) = "end" + ├── @ DefNode (location: (91,0)-(93,3)) + │ ├── name: :foo + │ ├── name_loc: (91,4)-(91,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (91,8)-(91,17)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (91,8)-(91,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :bar + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (91,13)-(91,17)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── name_loc: (91,14)-(91,17) = "baz" + │ │ │ └── operator_loc: (91,13)-(91,14) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (92,2)-(92,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (92,2)-(92,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar, :baz] + │ ├── def_keyword_loc: (91,0)-(91,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (91,7)-(91,8) = "(" + │ ├── rparen_loc: (91,17)-(91,18) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (93,0)-(93,3) = "end" + ├── @ DefNode (location: (95,0)-(97,3)) + │ ├── name: :foo + │ ├── name_loc: (95,4)-(95,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (95,8)-(95,24)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (95,8)-(95,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── name_loc: (95,8)-(95,11) = "baz" + │ │ │ ├── operator_loc: (95,12)-(95,13) = "=" + │ │ │ └── value: + │ │ │ @ TrueNode (location: (95,14)-(95,18)) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (95,20)-(95,24)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bor + │ │ │ ├── name_loc: (95,21)-(95,24) = "bor" + │ │ │ └── operator_loc: (95,20)-(95,21) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (96,2)-(96,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (96,2)-(96,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (96,2)-(96,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [:baz, :bor] + │ ├── def_keyword_loc: (95,0)-(95,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (95,7)-(95,8) = "(" + │ ├── rparen_loc: (95,24)-(95,25) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (97,0)-(97,3) = "end" + ├── @ DefNode (location: (99,0)-(101,3)) + │ ├── name: :foo + │ ├── name_loc: (99,4)-(99,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (99,8)-(99,32)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (99,8)-(99,18)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── name_loc: (99,8)-(99,11) = "baz" + │ │ │ ├── operator_loc: (99,12)-(99,13) = "=" + │ │ │ └── value: + │ │ │ @ TrueNode (location: (99,14)-(99,18)) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (99,20)-(99,24)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bor + │ │ │ ├── name_loc: (99,21)-(99,24) = "bor" + │ │ │ └── operator_loc: (99,20)-(99,21) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: + │ │ @ BlockParameterNode (location: (99,26)-(99,32)) + │ │ ├── flags: ∅ + │ │ ├── name: :block + │ │ ├── name_loc: (99,27)-(99,32) = "block" + │ │ └── operator_loc: (99,26)-(99,27) = "&" + │ ├── body: + │ │ @ StatementsNode (location: (100,2)-(100,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (100,2)-(100,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (100,2)-(100,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [:baz, :bor, :block] + │ ├── def_keyword_loc: (99,0)-(99,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (99,7)-(99,8) = "(" + │ ├── rparen_loc: (99,32)-(99,33) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (101,0)-(101,3) = "end" + ├── @ DefNode (location: (103,0)-(105,3)) + │ ├── name: :foo + │ ├── name_loc: (103,4)-(103,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (103,8)-(103,29)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (103,8)-(103,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :bar + │ │ ├── optionals: (length: 1) + │ │ │ └── @ OptionalParameterNode (location: (103,13)-(103,23)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── name_loc: (103,13)-(103,16) = "baz" + │ │ │ ├── operator_loc: (103,17)-(103,18) = "=" + │ │ │ └── value: + │ │ │ @ TrueNode (location: (103,19)-(103,23)) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (103,25)-(103,29)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :bor + │ │ │ ├── name_loc: (103,26)-(103,29) = "bor" + │ │ │ └── operator_loc: (103,25)-(103,26) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (104,2)-(104,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (104,2)-(104,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar, :baz, :bor] + │ ├── def_keyword_loc: (103,0)-(103,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (103,7)-(103,8) = "(" + │ ├── rparen_loc: (103,29)-(103,30) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (105,0)-(105,3) = "end" + ├── @ DefNode (location: (107,0)-(109,3)) + │ ├── name: :foo + │ ├── name_loc: (107,4)-(107,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (107,8)-(107,14)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: + │ │ @ BlockParameterNode (location: (107,8)-(107,14)) + │ │ ├── flags: ∅ + │ │ ├── name: :block + │ │ ├── name_loc: (107,9)-(107,14) = "block" + │ │ └── operator_loc: (107,8)-(107,9) = "&" + │ ├── body: + │ │ @ StatementsNode (location: (108,2)-(108,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (108,2)-(108,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (108,2)-(108,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [:block] + │ ├── def_keyword_loc: (107,0)-(107,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (107,7)-(107,8) = "(" + │ ├── rparen_loc: (107,14)-(107,15) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (109,0)-(109,3) = "end" + ├── @ DefNode (location: (111,0)-(113,3)) + │ ├── name: :foo + │ ├── name_loc: (111,4)-(111,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (111,8)-(111,19)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (111,8)-(111,11)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :bar + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: + │ │ @ BlockParameterNode (location: (111,13)-(111,19)) + │ │ ├── flags: ∅ + │ │ ├── name: :block + │ │ ├── name_loc: (111,14)-(111,19) = "block" + │ │ └── operator_loc: (111,13)-(111,14) = "&" + │ ├── body: + │ │ @ StatementsNode (location: (112,2)-(112,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (112,2)-(112,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── locals: [:bar, :block] + │ ├── def_keyword_loc: (111,0)-(111,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (111,7)-(111,8) = "(" + │ ├── rparen_loc: (111,19)-(111,20) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (113,0)-(113,3) = "end" + ├── @ DefNode (location: (115,0)-(118,3)) + │ ├── name: :foo + │ ├── name_loc: (115,4)-(115,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (116,2)-(117,5)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (116,2)-(116,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (116,2)-(116,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (117,2)-(117,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (117,2)-(117,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (115,0)-(115,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (118,0)-(118,3) = "end" + ├── @ DefNode (location: (120,0)-(121,3)) + │ ├── name: :f + │ ├── name_loc: (120,4)-(120,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (120,6)-(120,11)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ MultiTargetNode (location: (120,6)-(120,11)) + │ │ │ ├── lefts: (length: 1) + │ │ │ │ └── @ MultiTargetNode (location: (120,7)-(120,10)) + │ │ │ │ ├── lefts: (length: 1) + │ │ │ │ │ └── @ RequiredParameterNode (location: (120,8)-(120,9)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :a + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── rights: (length: 0) + │ │ │ │ ├── lparen_loc: (120,7)-(120,8) = "(" + │ │ │ │ └── rparen_loc: (120,9)-(120,10) = ")" + │ │ │ ├── rest: ∅ + │ │ │ ├── rights: (length: 0) + │ │ │ ├── lparen_loc: (120,6)-(120,7) = "(" + │ │ │ └── rparen_loc: (120,10)-(120,11) = ")" + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:a] + │ ├── def_keyword_loc: (120,0)-(120,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (120,5)-(120,6) = "(" + │ ├── rparen_loc: (120,11)-(120,12) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (121,0)-(121,3) = "end" + ├── @ DefNode (location: (123,0)-(124,3)) + │ ├── name: :foo + │ ├── name_loc: (123,4)-(123,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (123,8)-(123,26)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 2) + │ │ │ ├── @ RequiredKeywordParameterNode (location: (123,8)-(123,12)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ └── name_loc: (123,8)-(123,12) = "bar:" + │ │ │ └── @ OptionalKeywordParameterNode (location: (123,14)-(123,26)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── name_loc: (123,14)-(123,18) = "baz:" + │ │ │ └── value: + │ │ │ @ StringNode (location: (123,19)-(123,26)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (123,19)-(123,20) = "\"" + │ │ │ ├── content_loc: (123,20)-(123,25) = "value" + │ │ │ ├── closing_loc: (123,25)-(123,26) = "\"" + │ │ │ └── unescaped: "value" + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: ∅ + │ ├── locals: [:bar, :baz] + │ ├── def_keyword_loc: (123,0)-(123,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (123,7)-(123,8) = "(" + │ ├── rparen_loc: (123,26)-(123,27) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (124,0)-(124,3) = "end" + ├── @ DefNode (location: (126,0)-(130,3)) + │ ├── name: :f + │ ├── name_loc: (126,4)-(126,5) = "f" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (127,2)-(127,12)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (127,2)-(127,12)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (127,2)-(127,12) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (128,0)-(128,4)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (128,0)-(128,4) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (128,4)-(128,7)) + │ │ │ │ ├── opening_loc: (128,4)-(128,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (128,6)-(128,7) = "}" + │ │ │ └── @ StringNode (location: (128,7)-(129,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (128,7)-(129,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (129,0)-(130,0) = " HEREDOC\n" + │ ├── locals: [] + │ ├── def_keyword_loc: (126,0)-(126,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (130,0)-(130,3) = "end" + └── @ DefNode (location: (132,0)-(134,3)) + ├── name: :f + ├── name_loc: (132,4)-(132,5) = "f" + ├── receiver: ∅ + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (133,2)-(133,5)) + │ └── body: (length: 1) + │ └── @ StringNode (location: (133,2)-(133,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (133,2)-(133,4) = "%(" + │ ├── content_loc: (133,4)-(133,4) = "" + │ ├── closing_loc: (133,4)-(133,5) = ")" + │ └── unescaped: "" + ├── locals: [] + ├── def_keyword_loc: (132,0)-(132,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: ∅ + ├── rparen_loc: ∅ + ├── equal_loc: ∅ + └── end_keyword_loc: (134,0)-(134,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/defined.txt b/test/prism/snapshots/unparser/corpus/literal/defined.txt new file mode 100644 index 0000000000..89145ddcda --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/defined.txt @@ -0,0 +1,55 @@ +@ ProgramNode (location: (1,0)-(3,27)) +├── locals: [:a, :b] +└── statements: + @ StatementsNode (location: (1,0)-(3,27)) + └── body: (length: 3) + ├── @ DefinedNode (location: (1,0)-(1,14)) + │ ├── lparen_loc: (1,8)-(1,9) = "(" + │ ├── value: + │ │ @ InstanceVariableReadNode (location: (1,9)-(1,13)) + │ │ └── name: :@foo + │ ├── rparen_loc: (1,13)-(1,14) = ")" + │ └── keyword_loc: (1,0)-(1,8) = "defined?" + ├── @ DefinedNode (location: (2,0)-(2,13)) + │ ├── lparen_loc: (2,8)-(2,9) = "(" + │ ├── value: + │ │ @ ConstantReadNode (location: (2,9)-(2,12)) + │ │ └── name: :Foo + │ ├── rparen_loc: (2,12)-(2,13) = ")" + │ └── keyword_loc: (2,0)-(2,8) = "defined?" + └── @ DefinedNode (location: (3,0)-(3,27)) + ├── lparen_loc: (3,8)-(3,9) = "(" + ├── value: + │ @ ParenthesesNode (location: (3,9)-(3,26)) + │ ├── body: + │ │ @ StatementsNode (location: (3,10)-(3,25)) + │ │ └── body: (length: 1) + │ │ └── @ MultiWriteNode (location: (3,10)-(3,25)) + │ │ ├── lefts: (length: 2) + │ │ │ ├── @ LocalVariableTargetNode (location: (3,11)-(3,12)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ └── @ LocalVariableTargetNode (location: (3,14)-(3,15)) + │ │ │ ├── name: :b + │ │ │ └── depth: 0 + │ │ ├── rest: ∅ + │ │ ├── rights: (length: 0) + │ │ ├── lparen_loc: (3,10)-(3,11) = "(" + │ │ ├── rparen_loc: (3,15)-(3,16) = ")" + │ │ ├── operator_loc: (3,17)-(3,18) = "=" + │ │ └── value: + │ │ @ ArrayNode (location: (3,19)-(3,25)) + │ │ ├── flags: ∅ + │ │ ├── elements: (length: 2) + │ │ │ ├── @ IntegerNode (location: (3,20)-(3,21)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── @ IntegerNode (location: (3,23)-(3,24)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── opening_loc: (3,19)-(3,20) = "[" + │ │ └── closing_loc: (3,24)-(3,25) = "]" + │ ├── opening_loc: (3,9)-(3,10) = "(" + │ └── closing_loc: (3,25)-(3,26) = ")" + ├── rparen_loc: (3,26)-(3,27) = ")" + └── keyword_loc: (3,0)-(3,8) = "defined?" diff --git a/test/prism/snapshots/unparser/corpus/literal/defs.txt b/test/prism/snapshots/unparser/corpus/literal/defs.txt new file mode 100644 index 0000000000..7858877172 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/defs.txt @@ -0,0 +1,358 @@ +@ ProgramNode (location: (1,0)-(40,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(40,3)) + └── body: (length: 10) + ├── @ DefNode (location: (1,0)-(2,3)) + │ ├── name: :foo + │ ├── name_loc: (1,9)-(1,12) = "foo" + │ ├── receiver: + │ │ @ SelfNode (location: (1,4)-(1,8)) + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (1,0)-(1,3) = "def" + │ ├── operator_loc: (1,8)-(1,9) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (2,0)-(2,3) = "end" + ├── @ DefNode (location: (4,0)-(6,3)) + │ ├── name: :foo + │ ├── name_loc: (4,9)-(4,12) = "foo" + │ ├── receiver: + │ │ @ SelfNode (location: (4,4)-(4,8)) + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (5,2)-(5,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (5,2)-(5,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (5,2)-(5,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (4,0)-(4,3) = "def" + │ ├── operator_loc: (4,8)-(4,9) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (6,0)-(6,3) = "end" + ├── @ DefNode (location: (8,0)-(11,3)) + │ ├── name: :foo + │ ├── name_loc: (8,9)-(8,12) = "foo" + │ ├── receiver: + │ │ @ SelfNode (location: (8,4)-(8,8)) + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (9,2)-(10,5)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (9,2)-(9,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (9,2)-(9,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (10,2)-(10,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (10,2)-(10,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (8,0)-(8,3) = "def" + │ ├── operator_loc: (8,8)-(8,9) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ DefNode (location: (13,0)-(15,3)) + │ ├── name: :bar + │ ├── name_loc: (13,8)-(13,11) = "bar" + │ ├── receiver: + │ │ @ ConstantReadNode (location: (13,4)-(13,7)) + │ │ └── name: :Foo + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (14,2)-(14,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (14,2)-(14,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (14,2)-(14,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (13,0)-(13,3) = "def" + │ ├── operator_loc: (13,7)-(13,8) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (15,0)-(15,3) = "end" + ├── @ DefNode (location: (17,0)-(20,3)) + │ ├── name: :bar + │ ├── name_loc: (18,3)-(18,6) = "bar" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (17,4)-(18,2)) + │ │ ├── body: + │ │ │ @ CallNode (location: (17,5)-(18,1)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (17,5)-(17,8) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (17,9)-(18,1)) + │ │ │ ├── locals: [:bar] + │ │ │ ├── parameters: + │ │ │ │ @ BlockParametersNode (location: (17,11)-(17,16)) + │ │ │ │ ├── parameters: + │ │ │ │ │ @ ParametersNode (location: (17,12)-(17,15)) + │ │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ │ └── @ RequiredParameterNode (location: (17,12)-(17,15)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── name: :bar + │ │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ │ ├── rest: ∅ + │ │ │ │ │ ├── posts: (length: 0) + │ │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── locals: (length: 0) + │ │ │ │ ├── opening_loc: (17,11)-(17,12) = "|" + │ │ │ │ └── closing_loc: (17,15)-(17,16) = "|" + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (17,9)-(17,10) = "{" + │ │ │ └── closing_loc: (18,0)-(18,1) = "}" + │ │ ├── opening_loc: (17,4)-(17,5) = "(" + │ │ └── closing_loc: (18,1)-(18,2) = ")" + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (19,2)-(19,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (19,2)-(19,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (19,2)-(19,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (17,0)-(17,3) = "def" + │ ├── operator_loc: (18,2)-(18,3) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (20,0)-(20,3) = "end" + ├── @ DefNode (location: (22,0)-(24,3)) + │ ├── name: :bar + │ ├── name_loc: (22,13)-(22,16) = "bar" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (22,4)-(22,12)) + │ │ ├── body: + │ │ │ @ CallNode (location: (22,5)-(22,11)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (22,5)-(22,8) = "foo" + │ │ │ ├── opening_loc: (22,8)-(22,9) = "(" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (22,9)-(22,10)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (22,9)-(22,10)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── closing_loc: (22,10)-(22,11) = ")" + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (22,4)-(22,5) = "(" + │ │ └── closing_loc: (22,11)-(22,12) = ")" + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (23,2)-(23,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (23,2)-(23,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (23,2)-(23,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (22,0)-(22,3) = "def" + │ ├── operator_loc: (22,12)-(22,13) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (24,0)-(24,3) = "end" + ├── @ DefNode (location: (26,0)-(28,3)) + │ ├── name: :bar + │ ├── name_loc: (26,19)-(26,22) = "bar" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (26,4)-(26,18)) + │ │ ├── body: + │ │ │ @ CallNode (location: (26,5)-(26,17)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ ConstantPathNode (location: (26,5)-(26,13)) + │ │ │ │ ├── parent: + │ │ │ │ │ @ ConstantReadNode (location: (26,5)-(26,8)) + │ │ │ │ │ └── name: :Foo + │ │ │ │ ├── name: :Bar + │ │ │ │ ├── delimiter_loc: (26,8)-(26,10) = "::" + │ │ │ │ └── name_loc: (26,10)-(26,13) = "Bar" + │ │ │ ├── call_operator_loc: (26,13)-(26,14) = "." + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (26,14)-(26,17) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (26,4)-(26,5) = "(" + │ │ └── closing_loc: (26,17)-(26,18) = ")" + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (27,2)-(27,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (27,2)-(27,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (27,2)-(27,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (26,0)-(26,3) = "def" + │ ├── operator_loc: (26,18)-(26,19) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (28,0)-(28,3) = "end" + ├── @ DefNode (location: (30,0)-(32,3)) + │ ├── name: :bar + │ ├── name_loc: (30,15)-(30,18) = "bar" + │ ├── receiver: + │ │ @ ParenthesesNode (location: (30,4)-(30,14)) + │ │ ├── body: + │ │ │ @ ConstantPathNode (location: (30,5)-(30,13)) + │ │ │ ├── parent: + │ │ │ │ @ ConstantReadNode (location: (30,5)-(30,8)) + │ │ │ │ └── name: :Foo + │ │ │ ├── name: :Bar + │ │ │ ├── delimiter_loc: (30,8)-(30,10) = "::" + │ │ │ └── name_loc: (30,10)-(30,13) = "Bar" + │ │ ├── opening_loc: (30,4)-(30,5) = "(" + │ │ └── closing_loc: (30,13)-(30,14) = ")" + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (31,2)-(31,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (31,2)-(31,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (31,2)-(31,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (30,0)-(30,3) = "def" + │ ├── operator_loc: (30,14)-(30,15) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (32,0)-(32,3) = "end" + ├── @ DefNode (location: (34,0)-(36,3)) + │ ├── name: :bar + │ ├── name_loc: (34,8)-(34,11) = "bar" + │ ├── receiver: + │ │ @ ConstantReadNode (location: (34,4)-(34,7)) + │ │ └── name: :Foo + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (35,2)-(35,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (35,2)-(35,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (35,2)-(35,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── locals: [] + │ ├── def_keyword_loc: (34,0)-(34,3) = "def" + │ ├── operator_loc: (34,7)-(34,8) = "." + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (36,0)-(36,3) = "end" + └── @ DefNode (location: (38,0)-(40,3)) + ├── name: :bar + ├── name_loc: (38,8)-(38,11) = "bar" + ├── receiver: + │ @ CallNode (location: (38,4)-(38,7)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (38,4)-(38,7) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (39,2)-(39,5)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (39,2)-(39,5)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :baz + │ ├── message_loc: (39,2)-(39,5) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── locals: [] + ├── def_keyword_loc: (38,0)-(38,3) = "def" + ├── operator_loc: (38,7)-(38,8) = "." + ├── lparen_loc: ∅ + ├── rparen_loc: ∅ + ├── equal_loc: ∅ + └── end_keyword_loc: (40,0)-(40,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/dstr.txt b/test/prism/snapshots/unparser/corpus/literal/dstr.txt new file mode 100644 index 0000000000..8893e8b75d --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/dstr.txt @@ -0,0 +1,353 @@ +@ ProgramNode (location: (1,0)-(37,1)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(37,1)) + └── body: (length: 11) + ├── @ IfNode (location: (1,0)-(3,3)) + │ ├── if_keyword_loc: (1,0)-(1,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (1,3)-(1,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (2,2)-(2,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (2,2)-(2,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (2,2)-(2,3) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (2,3)-(2,6)) + │ │ │ │ ├── opening_loc: (2,3)-(2,5) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (2,5)-(2,6) = "}" + │ │ │ └── @ StringNode (location: (2,6)-(2,7)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (2,6)-(2,7) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── closing_loc: (2,7)-(2,8) = "\"" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ IfNode (location: (4,0)-(11,3)) + │ ├── if_keyword_loc: (4,0)-(4,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (4,3)-(4,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (5,2)-(10,3)) + │ │ └── body: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (5,2)-(5,12)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (5,2)-(5,12) = "<<-HEREDOC" + │ │ │ ├── parts: (length: 3) + │ │ │ │ ├── @ StringNode (location: (6,0)-(7,0)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (6,0)-(7,0) = "a\n" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a\n" + │ │ │ │ ├── @ EmbeddedStatementsNode (location: (7,0)-(7,3)) + │ │ │ │ │ ├── opening_loc: (7,0)-(7,2) = "\#{" + │ │ │ │ │ ├── statements: ∅ + │ │ │ │ │ └── closing_loc: (7,2)-(7,3) = "}" + │ │ │ │ └── @ StringNode (location: (7,3)-(9,0)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (7,3)-(9,0) = "a\nb\n" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "a\nb\n" + │ │ │ └── closing_loc: (9,0)-(10,0) = " HEREDOC\n" + │ │ └── @ CallNode (location: (10,2)-(10,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :x + │ │ ├── message_loc: (10,2)-(10,3) = "x" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ InterpolatedStringNode (location: (12,0)-(12,10)) + │ ├── flags: ∅ + │ ├── opening_loc: (12,0)-(12,10) = "<<-HEREDOC" + │ ├── parts: (length: 7) + │ │ ├── @ StringNode (location: (13,0)-(14,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (13,0)-(14,0) = "\\\#{}\\\#{}\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\#{}\#{}\n" + │ │ ├── @ EmbeddedStatementsNode (location: (14,0)-(14,3)) + │ │ │ ├── opening_loc: (14,0)-(14,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (14,2)-(14,3) = "}" + │ │ ├── @ StringNode (location: (14,3)-(15,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (14,3)-(15,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ ├── @ EmbeddedStatementsNode (location: (15,0)-(15,3)) + │ │ │ ├── opening_loc: (15,0)-(15,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (15,2)-(15,3) = "}" + │ │ ├── @ StringNode (location: (15,3)-(16,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (15,3)-(16,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ ├── @ EmbeddedStatementsNode (location: (16,0)-(16,3)) + │ │ │ ├── opening_loc: (16,0)-(16,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (16,2)-(16,3) = "}" + │ │ └── @ StringNode (location: (16,3)-(17,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (16,3)-(17,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (17,0)-(18,0) = "HEREDOC\n" + ├── @ RescueModifierNode (location: (18,0)-(18,21)) + │ ├── expression: + │ │ @ InterpolatedStringNode (location: (18,0)-(18,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (18,0)-(18,10) = "<<-HEREDOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (19,0)-(19,3)) + │ │ │ │ ├── opening_loc: (19,0)-(19,2) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (19,2)-(19,3) = "}" + │ │ │ └── @ StringNode (location: (19,3)-(21,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (19,3)-(21,0) = "\na\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\na\n" + │ │ └── closing_loc: (21,0)-(22,0) = "HEREDOC\n" + │ ├── keyword_loc: (18,11)-(18,17) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (18,18)-(18,21)) + ├── @ InterpolatedStringNode (location: (22,0)-(22,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (22,0)-(22,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (22,1)-(22,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (22,1)-(22,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (22,2)-(22,5)) + │ │ ├── operator_loc: (22,2)-(22,3) = "#" + │ │ └── variable: + │ │ @ NumberedReferenceReadNode (location: (22,3)-(22,5)) + │ │ └── number: 1 + │ └── closing_loc: (22,5)-(22,6) = "\"" + ├── @ InterpolatedStringNode (location: (23,0)-(23,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (23,0)-(23,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (23,1)-(23,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (23,1)-(23,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (23,2)-(23,5)) + │ │ ├── operator_loc: (23,2)-(23,3) = "#" + │ │ └── variable: + │ │ @ GlobalVariableReadNode (location: (23,3)-(23,5)) + │ │ └── name: :$a + │ └── closing_loc: (23,5)-(23,6) = "\"" + ├── @ InterpolatedStringNode (location: (24,0)-(24,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (24,0)-(24,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (24,1)-(24,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (24,1)-(24,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (24,2)-(24,5)) + │ │ ├── operator_loc: (24,2)-(24,3) = "#" + │ │ └── variable: + │ │ @ InstanceVariableReadNode (location: (24,3)-(24,5)) + │ │ └── name: :@a + │ └── closing_loc: (24,5)-(24,6) = "\"" + ├── @ InterpolatedStringNode (location: (25,0)-(25,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (25,0)-(25,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (25,1)-(25,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (25,1)-(25,2) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── @ EmbeddedVariableNode (location: (25,2)-(25,6)) + │ │ ├── operator_loc: (25,2)-(25,3) = "#" + │ │ └── variable: + │ │ @ ClassVariableReadNode (location: (25,3)-(25,6)) + │ │ └── name: :@@a + │ └── closing_loc: (25,6)-(25,7) = "\"" + ├── @ IfNode (location: (26,0)-(30,3)) + │ ├── if_keyword_loc: (26,0)-(26,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (26,3)-(26,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (27,2)-(27,19)) + │ │ └── body: (length: 1) + │ │ └── @ ReturnNode (location: (27,2)-(27,19)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (27,2)-(27,8) = "return" + │ │ └── arguments: + │ │ @ ArgumentsNode (location: (27,9)-(27,19)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (27,9)-(27,19)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (27,9)-(27,19) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (28,0)-(28,4)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (28,0)-(28,4) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (28,4)-(28,9)) + │ │ │ │ ├── opening_loc: (28,4)-(28,6) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (28,6)-(28,8)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ IntegerNode (location: (28,6)-(28,8)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 42 + │ │ │ │ └── closing_loc: (28,8)-(28,9) = "}" + │ │ │ └── @ StringNode (location: (28,9)-(29,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (28,9)-(29,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (29,0)-(30,0) = " HEREDOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (30,0)-(30,3) = "end" + ├── @ CallNode (location: (31,0)-(31,15)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (31,0)-(31,3) = "foo" + │ ├── opening_loc: (31,3)-(31,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (31,4)-(31,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (31,4)-(31,14)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (31,4)-(31,14) = "<<-HEREDOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (32,0)-(32,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (32,0)-(32,2) = " " + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: " " + │ │ │ ├── @ EmbeddedStatementsNode (location: (32,2)-(32,8)) + │ │ │ │ ├── opening_loc: (32,2)-(32,4) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (32,4)-(32,7)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (32,4)-(32,7)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :bar + │ │ │ │ │ ├── message_loc: (32,4)-(32,7) = "bar" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── closing_loc: (32,7)-(32,8) = "}" + │ │ │ └── @ StringNode (location: (32,8)-(33,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (32,8)-(33,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (33,0)-(34,0) = "HEREDOC\n" + │ ├── closing_loc: (31,14)-(31,15) = ")" + │ └── block: ∅ + └── @ CallNode (location: (34,0)-(37,1)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :foo + ├── message_loc: (34,0)-(34,3) = "foo" + ├── opening_loc: (34,3)-(34,4) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (34,4)-(34,14)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ InterpolatedStringNode (location: (34,4)-(34,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (34,4)-(34,14) = "<<-HEREDOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (35,0)-(35,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (35,0)-(35,2) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ ├── @ EmbeddedStatementsNode (location: (35,2)-(35,8)) + │ │ │ ├── opening_loc: (35,2)-(35,4) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (35,4)-(35,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (35,4)-(35,7)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (35,4)-(35,7) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── closing_loc: (35,7)-(35,8) = "}" + │ │ └── @ StringNode (location: (35,8)-(36,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (35,8)-(36,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (36,0)-(37,0) = "HEREDOC\n" + ├── closing_loc: (34,14)-(34,15) = ")" + └── block: + @ BlockNode (location: (34,16)-(37,1)) + ├── locals: [:x] + ├── parameters: + │ @ BlockParametersNode (location: (34,18)-(34,21)) + │ ├── parameters: + │ │ @ ParametersNode (location: (34,19)-(34,20)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (34,19)-(34,20)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :x + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── locals: (length: 0) + │ ├── opening_loc: (34,18)-(34,19) = "|" + │ └── closing_loc: (34,20)-(34,21) = "|" + ├── body: ∅ + ├── opening_loc: (34,16)-(34,17) = "{" + └── closing_loc: (37,0)-(37,1) = "}" diff --git a/test/prism/snapshots/unparser/corpus/literal/empty.txt b/test/prism/snapshots/unparser/corpus/literal/empty.txt new file mode 100644 index 0000000000..3a21ce5559 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/empty.txt @@ -0,0 +1,5 @@ +@ ProgramNode (location: (1,0)-(1,0)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(1,0)) + └── body: (length: 0) diff --git a/test/prism/snapshots/unparser/corpus/literal/empty_begin.txt b/test/prism/snapshots/unparser/corpus/literal/empty_begin.txt new file mode 100644 index 0000000000..838b4bf6f0 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/empty_begin.txt @@ -0,0 +1,9 @@ +@ ProgramNode (location: (1,0)-(1,2)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(1,2)) + └── body: (length: 1) + └── @ ParenthesesNode (location: (1,0)-(1,2)) + ├── body: ∅ + ├── opening_loc: (1,0)-(1,1) = "(" + └── closing_loc: (1,1)-(1,2) = ")" diff --git a/test/prism/snapshots/unparser/corpus/literal/flipflop.txt b/test/prism/snapshots/unparser/corpus/literal/flipflop.txt new file mode 100644 index 0000000000..2d9f669e6f --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/flipflop.txt @@ -0,0 +1,237 @@ +@ ProgramNode (location: (1,0)-(10,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(10,3)) + └── body: (length: 4) + ├── @ IfNode (location: (1,0)-(3,3)) + │ ├── if_keyword_loc: (1,0)-(1,2) = "if" + │ ├── predicate: + │ │ @ ParenthesesNode (location: (1,3)-(1,23)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (1,4)-(1,22)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ FlipFlopNode (location: (1,4)-(1,22)) + │ │ │ ├── flags: ∅ + │ │ │ ├── left: + │ │ │ │ @ ParenthesesNode (location: (1,4)-(1,12)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (1,5)-(1,11)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (1,5)-(1,11)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── receiver: + │ │ │ │ │ │ @ CallNode (location: (1,5)-(1,6)) + │ │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ │ ├── name: :i + │ │ │ │ │ │ ├── message_loc: (1,5)-(1,6) = "i" + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :== + │ │ │ │ │ ├── message_loc: (1,7)-(1,9) = "==" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: + │ │ │ │ │ │ @ ArgumentsNode (location: (1,10)-(1,11)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ │ └── @ IntegerNode (location: (1,10)-(1,11)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 4 + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── opening_loc: (1,4)-(1,5) = "(" + │ │ │ │ └── closing_loc: (1,11)-(1,12) = ")" + │ │ │ ├── right: + │ │ │ │ @ ParenthesesNode (location: (1,14)-(1,22)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (1,15)-(1,21)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (1,15)-(1,21)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── receiver: + │ │ │ │ │ │ @ CallNode (location: (1,15)-(1,16)) + │ │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ │ ├── name: :i + │ │ │ │ │ │ ├── message_loc: (1,15)-(1,16) = "i" + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :== + │ │ │ │ │ ├── message_loc: (1,17)-(1,19) = "==" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: + │ │ │ │ │ │ @ ArgumentsNode (location: (1,20)-(1,21)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ │ └── @ IntegerNode (location: (1,20)-(1,21)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 4 + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── opening_loc: (1,14)-(1,15) = "(" + │ │ │ │ └── closing_loc: (1,21)-(1,22) = ")" + │ │ │ └── operator_loc: (1,12)-(1,14) = ".." + │ │ ├── opening_loc: (1,3)-(1,4) = "(" + │ │ └── closing_loc: (1,22)-(1,23) = ")" + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (2,2)-(2,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (2,2)-(2,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (2,2)-(2,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ IfNode (location: (4,0)-(6,3)) + │ ├── if_keyword_loc: (4,0)-(4,2) = "if" + │ ├── predicate: + │ │ @ ParenthesesNode (location: (4,3)-(4,24)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (4,4)-(4,23)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ FlipFlopNode (location: (4,4)-(4,23)) + │ │ │ ├── flags: exclude_end + │ │ │ ├── left: + │ │ │ │ @ ParenthesesNode (location: (4,4)-(4,12)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (4,5)-(4,11)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (4,5)-(4,11)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── receiver: + │ │ │ │ │ │ @ CallNode (location: (4,5)-(4,6)) + │ │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ │ ├── name: :i + │ │ │ │ │ │ ├── message_loc: (4,5)-(4,6) = "i" + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :== + │ │ │ │ │ ├── message_loc: (4,7)-(4,9) = "==" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: + │ │ │ │ │ │ @ ArgumentsNode (location: (4,10)-(4,11)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ │ └── @ IntegerNode (location: (4,10)-(4,11)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 4 + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── opening_loc: (4,4)-(4,5) = "(" + │ │ │ │ └── closing_loc: (4,11)-(4,12) = ")" + │ │ │ ├── right: + │ │ │ │ @ ParenthesesNode (location: (4,15)-(4,23)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (4,16)-(4,22)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ CallNode (location: (4,16)-(4,22)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ ├── receiver: + │ │ │ │ │ │ @ CallNode (location: (4,16)-(4,17)) + │ │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ │ ├── name: :i + │ │ │ │ │ │ ├── message_loc: (4,16)-(4,17) = "i" + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :== + │ │ │ │ │ ├── message_loc: (4,18)-(4,20) = "==" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: + │ │ │ │ │ │ @ ArgumentsNode (location: (4,21)-(4,22)) + │ │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ │ └── arguments: (length: 1) + │ │ │ │ │ │ └── @ IntegerNode (location: (4,21)-(4,22)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 4 + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── opening_loc: (4,15)-(4,16) = "(" + │ │ │ │ └── closing_loc: (4,22)-(4,23) = ")" + │ │ │ └── operator_loc: (4,12)-(4,15) = "..." + │ │ ├── opening_loc: (4,3)-(4,4) = "(" + │ │ └── closing_loc: (4,23)-(4,24) = ")" + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (5,2)-(5,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (5,2)-(5,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (5,2)-(5,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (6,0)-(6,3) = "end" + ├── @ IfNode (location: (7,0)-(8,3)) + │ ├── if_keyword_loc: (7,0)-(7,2) = "if" + │ ├── predicate: + │ │ @ FlipFlopNode (location: (7,3)-(7,8)) + │ │ ├── flags: ∅ + │ │ ├── left: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (7,5)-(7,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (7,5)-(7,8) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (7,3)-(7,5) = ".." + │ ├── then_keyword_loc: ∅ + │ ├── statements: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (8,0)-(8,3) = "end" + └── @ IfNode (location: (9,0)-(10,3)) + ├── if_keyword_loc: (9,0)-(9,2) = "if" + ├── predicate: + │ @ FlipFlopNode (location: (9,3)-(9,8)) + │ ├── flags: ∅ + │ ├── left: + │ │ @ CallNode (location: (9,3)-(9,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (9,3)-(9,6) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── right: ∅ + │ └── operator_loc: (9,6)-(9,8) = ".." + ├── then_keyword_loc: ∅ + ├── statements: ∅ + ├── consequent: ∅ + └── end_keyword_loc: (10,0)-(10,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/for.txt b/test/prism/snapshots/unparser/corpus/literal/for.txt new file mode 100644 index 0000000000..660c6b73f3 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/for.txt @@ -0,0 +1,171 @@ +@ ProgramNode (location: (1,0)-(12,3)) +├── locals: [:a, :b] +└── statements: + @ StatementsNode (location: (1,0)-(12,3)) + └── body: (length: 4) + ├── @ CallNode (location: (1,0)-(3,4)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (1,0)-(1,3) = "bar" + │ ├── opening_loc: (1,3)-(1,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (1,4)-(3,3)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ForNode (location: (1,4)-(3,3)) + │ │ ├── index: + │ │ │ @ LocalVariableTargetNode (location: (1,8)-(1,9)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── collection: + │ │ │ @ CallNode (location: (1,13)-(1,16)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (1,13)-(1,16) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (2,2)-(2,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (2,2)-(2,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (2,2)-(2,5) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── for_keyword_loc: (1,4)-(1,7) = "for" + │ │ ├── in_keyword_loc: (1,10)-(1,12) = "in" + │ │ ├── do_keyword_loc: (1,17)-(1,19) = "do" + │ │ └── end_keyword_loc: (3,0)-(3,3) = "end" + │ ├── closing_loc: (3,3)-(3,4) = ")" + │ └── block: ∅ + ├── @ ForNode (location: (4,0)-(6,3)) + │ ├── index: + │ │ @ LocalVariableTargetNode (location: (4,4)-(4,5)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── collection: + │ │ @ CallNode (location: (4,9)-(4,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (4,9)-(4,12) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (5,2)-(5,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (5,2)-(5,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (5,2)-(5,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── for_keyword_loc: (4,0)-(4,3) = "for" + │ ├── in_keyword_loc: (4,6)-(4,8) = "in" + │ ├── do_keyword_loc: (4,13)-(4,15) = "do" + │ └── end_keyword_loc: (6,0)-(6,3) = "end" + ├── @ ForNode (location: (7,0)-(9,3)) + │ ├── index: + │ │ @ MultiTargetNode (location: (7,4)-(7,11)) + │ │ ├── lefts: (length: 1) + │ │ │ └── @ LocalVariableTargetNode (location: (7,5)-(7,6)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── rest: + │ │ │ @ SplatNode (location: (7,8)-(7,10)) + │ │ │ ├── operator_loc: (7,8)-(7,9) = "*" + │ │ │ └── expression: + │ │ │ @ LocalVariableTargetNode (location: (7,9)-(7,10)) + │ │ │ ├── name: :b + │ │ │ └── depth: 0 + │ │ ├── rights: (length: 0) + │ │ ├── lparen_loc: (7,4)-(7,5) = "(" + │ │ └── rparen_loc: (7,10)-(7,11) = ")" + │ ├── collection: + │ │ @ CallNode (location: (7,15)-(7,18)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (7,15)-(7,18) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (8,2)-(8,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (8,2)-(8,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (8,2)-(8,5) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── for_keyword_loc: (7,0)-(7,3) = "for" + │ ├── in_keyword_loc: (7,12)-(7,14) = "in" + │ ├── do_keyword_loc: (7,19)-(7,21) = "do" + │ └── end_keyword_loc: (9,0)-(9,3) = "end" + └── @ ForNode (location: (10,0)-(12,3)) + ├── index: + │ @ MultiTargetNode (location: (10,4)-(10,10)) + │ ├── lefts: (length: 2) + │ │ ├── @ LocalVariableTargetNode (location: (10,5)-(10,6)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ └── @ LocalVariableTargetNode (location: (10,8)-(10,9)) + │ │ ├── name: :b + │ │ └── depth: 0 + │ ├── rest: ∅ + │ ├── rights: (length: 0) + │ ├── lparen_loc: (10,4)-(10,5) = "(" + │ └── rparen_loc: (10,9)-(10,10) = ")" + ├── collection: + │ @ CallNode (location: (10,14)-(10,17)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (10,14)-(10,17) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── statements: + │ @ StatementsNode (location: (11,2)-(11,5)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (11,2)-(11,5)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :baz + │ ├── message_loc: (11,2)-(11,5) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── for_keyword_loc: (10,0)-(10,3) = "for" + ├── in_keyword_loc: (10,11)-(10,13) = "in" + ├── do_keyword_loc: (10,18)-(10,20) = "do" + └── end_keyword_loc: (12,0)-(12,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/hookexe.txt b/test/prism/snapshots/unparser/corpus/literal/hookexe.txt new file mode 100644 index 0000000000..dabedbc588 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/hookexe.txt @@ -0,0 +1,49 @@ +@ ProgramNode (location: (1,0)-(7,1)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(7,1)) + └── body: (length: 3) + ├── @ PreExecutionNode (location: (1,0)-(3,1)) + │ ├── statements: + │ │ @ StatementsNode (location: (2,2)-(2,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (2,2)-(2,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (2,2)-(2,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── keyword_loc: (1,0)-(1,5) = "BEGIN" + │ ├── opening_loc: (1,6)-(1,7) = "{" + │ └── closing_loc: (3,0)-(3,1) = "}" + ├── @ CallNode (location: (4,0)-(4,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (4,0)-(4,3) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ PostExecutionNode (location: (5,0)-(7,1)) + ├── statements: + │ @ StatementsNode (location: (6,2)-(6,5)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (6,2)-(6,5)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :baz + │ ├── message_loc: (6,2)-(6,5) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── keyword_loc: (5,0)-(5,3) = "END" + ├── opening_loc: (5,4)-(5,5) = "{" + └── closing_loc: (7,0)-(7,1) = "}" diff --git a/test/prism/snapshots/unparser/corpus/literal/if.txt b/test/prism/snapshots/unparser/corpus/literal/if.txt new file mode 100644 index 0000000000..00eeba179c --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/if.txt @@ -0,0 +1,288 @@ +@ ProgramNode (location: (1,0)-(36,3)) +├── locals: [:foo, :pair] +└── statements: + @ StatementsNode (location: (1,0)-(36,3)) + └── body: (length: 10) + ├── @ IfNode (location: (1,0)-(3,3)) + │ ├── if_keyword_loc: (1,0)-(1,2) = "if" + │ ├── predicate: + │ │ @ MatchLastLineNode (location: (1,3)-(1,8)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (1,3)-(1,4) = "/" + │ │ ├── content_loc: (1,4)-(1,7) = "foo" + │ │ ├── closing_loc: (1,7)-(1,8) = "/" + │ │ └── unescaped: "foo" + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (2,2)-(2,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (2,2)-(2,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (2,2)-(2,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ IfNode (location: (4,0)-(6,3)) + │ ├── if_keyword_loc: (4,0)-(4,2) = "if" + │ ├── predicate: + │ │ @ IntegerNode (location: (4,3)-(4,4)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (5,2)-(5,3)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (5,2)-(5,3)) + │ │ ├── flags: decimal + │ │ └── value: 9 + │ ├── consequent: ∅ + │ └── end_keyword_loc: (6,0)-(6,3) = "end" + ├── @ IfNode (location: (7,0)-(11,3)) + │ ├── if_keyword_loc: (7,0)-(7,2) = "if" + │ ├── predicate: + │ │ @ IntegerNode (location: (7,3)-(7,4)) + │ │ ├── flags: decimal + │ │ └── value: 4 + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (8,2)-(8,3)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (8,2)-(8,3)) + │ │ ├── flags: decimal + │ │ └── value: 5 + │ ├── consequent: + │ │ @ ElseNode (location: (9,0)-(11,3)) + │ │ ├── else_keyword_loc: (9,0)-(9,4) = "else" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (10,2)-(10,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ IntegerNode (location: (10,2)-(10,3)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 6 + │ │ └── end_keyword_loc: (11,0)-(11,3) = "end" + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ UnlessNode (location: (12,0)-(14,3)) + │ ├── keyword_loc: (12,0)-(12,6) = "unless" + │ ├── predicate: + │ │ @ IntegerNode (location: (12,7)-(12,8)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (13,2)-(13,5)) + │ │ └── body: (length: 1) + │ │ └── @ NilNode (location: (13,2)-(13,5)) + │ ├── consequent: ∅ + │ └── end_keyword_loc: (14,0)-(14,3) = "end" + ├── @ UnlessNode (location: (15,0)-(17,3)) + │ ├── keyword_loc: (15,0)-(15,6) = "unless" + │ ├── predicate: + │ │ @ IntegerNode (location: (15,7)-(15,8)) + │ │ ├── flags: decimal + │ │ └── value: 3 + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (16,2)-(16,3)) + │ │ └── body: (length: 1) + │ │ └── @ IntegerNode (location: (16,2)-(16,3)) + │ │ ├── flags: decimal + │ │ └── value: 9 + │ ├── consequent: ∅ + │ └── end_keyword_loc: (17,0)-(17,3) = "end" + ├── @ IfNode (location: (18,0)-(19,3)) + │ ├── if_keyword_loc: (18,0)-(18,2) = "if" + │ ├── predicate: + │ │ @ CallNode (location: (18,3)-(18,6)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (18,3)-(18,6) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── then_keyword_loc: ∅ + │ ├── statements: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (19,0)-(19,3) = "end" + ├── @ ModuleNode (location: (21,0)-(23,3)) + │ ├── locals: [:foo] + │ ├── module_keyword_loc: (21,0)-(21,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (21,7)-(21,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (22,2)-(22,18)) + │ │ └── body: (length: 1) + │ │ └── @ IfNode (location: (22,2)-(22,18)) + │ │ ├── if_keyword_loc: (22,12)-(22,14) = "if" + │ │ ├── predicate: + │ │ │ @ LocalVariableReadNode (location: (22,15)-(22,18)) + │ │ │ ├── name: :foo + │ │ │ └── depth: 0 + │ │ ├── then_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (22,2)-(22,11)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableWriteNode (location: (22,2)-(22,11)) + │ │ │ ├── name: :foo + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (22,2)-(22,5) = "foo" + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (22,8)-(22,11)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (22,8)-(22,11) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (22,6)-(22,7) = "=" + │ │ ├── consequent: ∅ + │ │ └── end_keyword_loc: ∅ + │ ├── end_keyword_loc: (23,0)-(23,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (25,0)-(27,3)) + │ ├── locals: [:foo] + │ ├── module_keyword_loc: (25,0)-(25,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (25,7)-(25,8)) + │ │ └── name: :B + │ ├── body: + │ │ @ StatementsNode (location: (26,2)-(26,22)) + │ │ └── body: (length: 1) + │ │ └── @ UnlessNode (location: (26,2)-(26,22)) + │ │ ├── keyword_loc: (26,12)-(26,18) = "unless" + │ │ ├── predicate: + │ │ │ @ LocalVariableReadNode (location: (26,19)-(26,22)) + │ │ │ ├── name: :foo + │ │ │ └── depth: 0 + │ │ ├── then_keyword_loc: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (26,2)-(26,11)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableWriteNode (location: (26,2)-(26,11)) + │ │ │ ├── name: :foo + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (26,2)-(26,5) = "foo" + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (26,8)-(26,11)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (26,8)-(26,11) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (26,6)-(26,7) = "=" + │ │ ├── consequent: ∅ + │ │ └── end_keyword_loc: ∅ + │ ├── end_keyword_loc: (27,0)-(27,3) = "end" + │ └── name: :B + ├── @ UnlessNode (location: (28,0)-(30,3)) + │ ├── keyword_loc: (28,0)-(28,6) = "unless" + │ ├── predicate: + │ │ @ CallNode (location: (28,7)-(28,10)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (28,7)-(28,10) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (29,2)-(29,11)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableWriteNode (location: (29,2)-(29,11)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (29,2)-(29,5) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (29,8)-(29,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (29,8)-(29,11) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (29,6)-(29,7) = "=" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (30,0)-(30,3) = "end" + └── @ IfNode (location: (31,0)-(36,3)) + ├── if_keyword_loc: (31,0)-(31,2) = "if" + ├── predicate: + │ @ CallNode (location: (31,3)-(33,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (31,3)-(31,6) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (31,7)-(33,1)) + │ ├── locals: [:pair] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (31,9)-(31,15)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (31,10)-(31,14)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (31,10)-(31,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :pair + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (31,9)-(31,10) = "|" + │ │ └── closing_loc: (31,14)-(31,15) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (32,2)-(32,6)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (32,2)-(32,6)) + │ │ ├── name: :pair + │ │ └── depth: 0 + │ ├── opening_loc: (31,7)-(31,8) = "{" + │ └── closing_loc: (33,0)-(33,1) = "}" + ├── then_keyword_loc: ∅ + ├── statements: + │ @ StatementsNode (location: (34,2)-(35,5)) + │ └── body: (length: 2) + │ ├── @ LocalVariableWriteNode (location: (34,2)-(34,13)) + │ │ ├── name: :pair + │ │ ├── depth: 0 + │ │ ├── name_loc: (34,2)-(34,6) = "pair" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (34,9)-(34,13)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (34,9)-(34,10) = ":" + │ │ │ ├── value_loc: (34,10)-(34,13) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ └── operator_loc: (34,7)-(34,8) = "=" + │ └── @ LocalVariableReadNode (location: (35,2)-(35,5)) + │ ├── name: :foo + │ └── depth: 0 + ├── consequent: ∅ + └── end_keyword_loc: (36,0)-(36,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/kwbegin.txt b/test/prism/snapshots/unparser/corpus/literal/kwbegin.txt new file mode 100644 index 0000000000..48e53af00e --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/kwbegin.txt @@ -0,0 +1,491 @@ +@ ProgramNode (location: (1,0)-(80,3)) +├── locals: [:foo, :bar, :exception] +└── statements: + @ StatementsNode (location: (1,0)-(80,3)) + └── body: (length: 14) + ├── @ BeginNode (location: (1,0)-(3,3)) + │ ├── begin_keyword_loc: (1,0)-(1,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (2,0)-(2,6)) + │ │ ├── keyword_loc: (2,0)-(2,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ BeginNode (location: (5,0)-(7,3)) + │ ├── begin_keyword_loc: (5,0)-(5,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: + │ │ @ EnsureNode (location: (6,0)-(7,3)) + │ │ ├── ensure_keyword_loc: (6,0)-(6,6) = "ensure" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (7,0)-(7,3) = "end" + │ └── end_keyword_loc: (7,0)-(7,3) = "end" + ├── @ BeginNode (location: (9,0)-(11,3)) + │ ├── begin_keyword_loc: (9,0)-(9,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (10,2)-(10,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (10,2)-(10,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (10,2)-(10,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ BeginNode (location: (13,0)-(17,3)) + │ ├── begin_keyword_loc: (13,0)-(13,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (14,2)-(14,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (14,2)-(14,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (14,2)-(14,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (15,0)-(16,3)) + │ │ ├── keyword_loc: (15,0)-(15,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (16,2)-(16,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (16,2)-(16,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (16,2)-(16,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (17,0)-(17,3) = "end" + ├── @ BeginNode (location: (19,0)-(24,3)) + │ ├── begin_keyword_loc: (19,0)-(19,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (20,2)-(21,3)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (20,2)-(20,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (20,2)-(20,3) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ 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: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (22,0)-(23,3)) + │ │ ├── keyword_loc: (22,0)-(22,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (23,2)-(23,3)) + │ │ │ └── body: (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: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (24,0)-(24,3) = "end" + ├── @ BeginNode (location: (26,0)-(28,3)) + │ ├── begin_keyword_loc: (26,0)-(26,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (27,0)-(27,8)) + │ │ ├── keyword_loc: (27,0)-(27,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (27,7)-(27,8)) + │ │ │ └── name: :A + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (28,0)-(28,3) = "end" + ├── @ BeginNode (location: (30,0)-(32,3)) + │ ├── begin_keyword_loc: (30,0)-(30,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (31,0)-(31,15)) + │ │ ├── keyword_loc: (31,0)-(31,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (31,7)-(31,8)) + │ │ │ └── name: :A + │ │ ├── operator_loc: (31,9)-(31,11) = "=>" + │ │ ├── reference: + │ │ │ @ LocalVariableTargetNode (location: (31,12)-(31,15)) + │ │ │ ├── name: :foo + │ │ │ └── depth: 0 + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (32,0)-(32,3) = "end" + ├── @ BeginNode (location: (34,0)-(42,3)) + │ ├── begin_keyword_loc: (34,0)-(34,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (35,2)-(35,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (35,2)-(35,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (35,2)-(35,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (36,0)-(39,3)) + │ │ ├── keyword_loc: (36,0)-(36,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (36,7)-(36,8)) + │ │ │ └── name: :A + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (37,2)-(37,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (37,2)-(37,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (37,2)-(37,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: + │ │ @ RescueNode (location: (38,0)-(39,3)) + │ │ ├── keyword_loc: (38,0)-(38,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (38,7)-(38,8)) + │ │ │ └── name: :B + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (39,2)-(39,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (39,2)-(39,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (39,2)-(39,3) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: + │ │ @ EnsureNode (location: (40,0)-(42,3)) + │ │ ├── ensure_keyword_loc: (40,0)-(40,6) = "ensure" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (41,2)-(41,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (41,2)-(41,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (41,2)-(41,3) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── end_keyword_loc: (42,0)-(42,3) = "end" + │ └── end_keyword_loc: (42,0)-(42,3) = "end" + ├── @ BeginNode (location: (44,0)-(53,3)) + │ ├── begin_keyword_loc: (44,0)-(44,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (45,2)-(49,5)) + │ │ └── body: (length: 1) + │ │ └── @ BeginNode (location: (45,2)-(49,5)) + │ │ ├── begin_keyword_loc: (45,2)-(45,7) = "begin" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (46,4)-(47,7)) + │ │ │ └── body: (length: 2) + │ │ │ ├── @ LocalVariableReadNode (location: (46,4)-(46,7)) + │ │ │ │ ├── name: :foo + │ │ │ │ └── depth: 0 + │ │ │ └── @ CallNode (location: (47,4)-(47,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (47,4)-(47,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (48,2)-(48,8)) + │ │ │ ├── keyword_loc: (48,2)-(48,8) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (49,2)-(49,5) = "end" + │ ├── rescue_clause: + │ │ @ RescueNode (location: (50,0)-(52,5)) + │ │ ├── keyword_loc: (50,0)-(50,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (51,2)-(52,5)) + │ │ │ └── body: (length: 2) + │ │ │ ├── @ CallNode (location: (51,2)-(51,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (51,2)-(51,5) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── @ CallNode (location: (52,2)-(52,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (52,2)-(52,5) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (53,0)-(53,3) = "end" + ├── @ BeginNode (location: (55,0)-(58,3)) + │ ├── begin_keyword_loc: (55,0)-(55,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (56,2)-(56,35)) + │ │ └── body: (length: 1) + │ │ └── @ RescueModifierNode (location: (56,2)-(56,35)) + │ │ ├── expression: + │ │ │ @ CallNode (location: (56,2)-(56,18)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :raise + │ │ │ ├── message_loc: (56,2)-(56,7) = "raise" + │ │ │ ├── opening_loc: (56,7)-(56,8) = "(" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (56,8)-(56,17)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ ConstantReadNode (location: (56,8)-(56,17)) + │ │ │ │ └── name: :Exception + │ │ │ ├── closing_loc: (56,17)-(56,18) = ")" + │ │ │ └── block: ∅ + │ │ ├── keyword_loc: (56,19)-(56,25) = "rescue" + │ │ └── rescue_expression: + │ │ @ LocalVariableWriteNode (location: (56,26)-(56,35)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (56,26)-(56,29) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (56,32)-(56,35)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (56,32)-(56,35) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (56,30)-(56,31) = "=" + │ ├── rescue_clause: + │ │ @ RescueNode (location: (57,0)-(57,16)) + │ │ ├── keyword_loc: (57,0)-(57,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (57,7)-(57,16)) + │ │ │ └── name: :Exception + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (58,0)-(58,3) = "end" + ├── @ BeginNode (location: (60,0)-(64,3)) + │ ├── begin_keyword_loc: (60,0)-(60,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (61,2)-(61,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (61,2)-(61,5)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── rescue_clause: + │ │ @ RescueNode (location: (62,0)-(63,5)) + │ │ ├── keyword_loc: (62,0)-(62,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: (62,7)-(62,9) = "=>" + │ │ ├── reference: + │ │ │ @ LocalVariableTargetNode (location: (62,10)-(62,13)) + │ │ │ ├── name: :bar + │ │ │ └── depth: 0 + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (63,2)-(63,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableReadNode (location: (63,2)-(63,5)) + │ │ │ ├── name: :bar + │ │ │ └── depth: 0 + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (64,0)-(64,3) = "end" + ├── @ BeginNode (location: (66,0)-(70,3)) + │ ├── begin_keyword_loc: (66,0)-(66,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (67,2)-(67,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (67,2)-(67,5)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── rescue_clause: + │ │ @ RescueNode (location: (68,0)-(69,5)) + │ │ ├── keyword_loc: (68,0)-(68,6) = "rescue" + │ │ ├── exceptions: (length: 2) + │ │ │ ├── @ ConstantReadNode (location: (68,7)-(68,16)) + │ │ │ │ └── name: :Exception + │ │ │ └── @ ConstantReadNode (location: (68,18)-(68,23)) + │ │ │ └── name: :Other + │ │ ├── operator_loc: (68,24)-(68,26) = "=>" + │ │ ├── reference: + │ │ │ @ LocalVariableTargetNode (location: (68,27)-(68,30)) + │ │ │ ├── name: :bar + │ │ │ └── depth: 0 + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (69,2)-(69,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableReadNode (location: (69,2)-(69,5)) + │ │ │ ├── name: :bar + │ │ │ └── depth: 0 + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (70,0)-(70,3) = "end" + ├── @ BeginNode (location: (72,0)-(76,3)) + │ ├── begin_keyword_loc: (72,0)-(72,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (73,2)-(73,5)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (73,2)-(73,5)) + │ │ ├── name: :bar + │ │ └── depth: 0 + │ ├── rescue_clause: + │ │ @ RescueNode (location: (74,0)-(75,5)) + │ │ ├── keyword_loc: (74,0)-(74,6) = "rescue" + │ │ ├── exceptions: (length: 2) + │ │ │ ├── @ ConstantReadNode (location: (74,7)-(74,16)) + │ │ │ │ └── name: :SomeError + │ │ │ └── @ SplatNode (location: (74,18)-(74,22)) + │ │ │ ├── operator_loc: (74,18)-(74,19) = "*" + │ │ │ └── expression: + │ │ │ @ LocalVariableReadNode (location: (74,19)-(74,22)) + │ │ │ ├── name: :bar + │ │ │ └── depth: 0 + │ │ ├── operator_loc: (74,23)-(74,25) = "=>" + │ │ ├── reference: + │ │ │ @ LocalVariableTargetNode (location: (74,26)-(74,35)) + │ │ │ ├── name: :exception + │ │ │ └── depth: 0 + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (75,2)-(75,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (75,2)-(75,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (75,2)-(75,5) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (76,0)-(76,3) = "end" + └── @ SingletonClassNode (location: (78,0)-(80,3)) + ├── locals: [] + ├── class_keyword_loc: (78,0)-(78,5) = "class" + ├── operator_loc: (78,6)-(78,8) = "<<" + ├── expression: + │ @ SelfNode (location: (78,9)-(78,13)) + ├── body: + │ @ StatementsNode (location: (79,2)-(79,23)) + │ └── body: (length: 1) + │ └── @ RescueModifierNode (location: (79,2)-(79,23)) + │ ├── expression: + │ │ @ UndefNode (location: (79,2)-(79,12)) + │ │ ├── names: (length: 1) + │ │ │ └── @ SymbolNode (location: (79,8)-(79,12)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (79,8)-(79,9) = ":" + │ │ │ ├── value_loc: (79,9)-(79,12) = "bar" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "bar" + │ │ └── keyword_loc: (79,2)-(79,7) = "undef" + │ ├── keyword_loc: (79,13)-(79,19) = "rescue" + │ └── rescue_expression: + │ @ NilNode (location: (79,20)-(79,23)) + └── end_keyword_loc: (80,0)-(80,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/lambda.txt b/test/prism/snapshots/unparser/corpus/literal/lambda.txt new file mode 100644 index 0000000000..3594787bca --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/lambda.txt @@ -0,0 +1,151 @@ +@ ProgramNode (location: (1,0)-(13,1)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(13,1)) + └── body: (length: 6) + ├── @ CallNode (location: (1,0)-(2,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :lambda + │ ├── message_loc: (1,0)-(1,6) = "lambda" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (1,7)-(2,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (1,7)-(1,8) = "{" + │ └── closing_loc: (2,0)-(2,1) = "}" + ├── @ CallNode (location: (3,0)-(5,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :lambda + │ ├── message_loc: (3,0)-(3,6) = "lambda" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (3,7)-(5,1)) + │ ├── locals: [:a, :b] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (3,9)-(3,15)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (3,10)-(3,14)) + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ RequiredParameterNode (location: (3,10)-(3,11)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :a + │ │ │ │ └── @ RequiredParameterNode (location: (3,13)-(3,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :b + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (3,9)-(3,10) = "|" + │ │ └── closing_loc: (3,14)-(3,15) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (4,2)-(4,3)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (4,2)-(4,3)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── opening_loc: (3,7)-(3,8) = "{" + │ └── closing_loc: (5,0)-(5,1) = "}" + ├── @ LambdaNode (location: (6,0)-(7,1)) + │ ├── locals: [] + │ ├── operator_loc: (6,0)-(6,2) = "->" + │ ├── opening_loc: (6,5)-(6,6) = "{" + │ ├── closing_loc: (7,0)-(7,1) = "}" + │ ├── parameters: + │ │ @ BlockParametersNode (location: (6,2)-(6,4)) + │ │ ├── parameters: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (6,2)-(6,3) = "(" + │ │ └── closing_loc: (6,3)-(6,4) = ")" + │ └── body: ∅ + ├── @ LambdaNode (location: (8,0)-(9,1)) + │ ├── locals: [:a] + │ ├── operator_loc: (8,0)-(8,2) = "->" + │ ├── opening_loc: (8,6)-(8,7) = "{" + │ ├── closing_loc: (9,0)-(9,1) = "}" + │ ├── parameters: + │ │ @ BlockParametersNode (location: (8,2)-(8,5)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (8,3)-(8,4)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (8,3)-(8,4)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (8,2)-(8,3) = "(" + │ │ └── closing_loc: (8,4)-(8,5) = ")" + │ └── body: ∅ + ├── @ LambdaNode (location: (10,0)-(11,1)) + │ ├── locals: [:a, :b] + │ ├── operator_loc: (10,0)-(10,2) = "->" + │ ├── opening_loc: (10,9)-(10,10) = "{" + │ ├── closing_loc: (11,0)-(11,1) = "}" + │ ├── parameters: + │ │ @ BlockParametersNode (location: (10,2)-(10,8)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (10,3)-(10,7)) + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ RequiredParameterNode (location: (10,3)-(10,4)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :a + │ │ │ │ └── @ RequiredParameterNode (location: (10,6)-(10,7)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :b + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (10,2)-(10,3) = "(" + │ │ └── closing_loc: (10,7)-(10,8) = ")" + │ └── body: ∅ + └── @ LambdaNode (location: (12,0)-(13,1)) + ├── locals: [:a, :b, :c] + ├── operator_loc: (12,0)-(12,2) = "->" + ├── opening_loc: (12,12)-(12,13) = "{" + ├── closing_loc: (13,0)-(13,1) = "}" + ├── parameters: + │ @ BlockParametersNode (location: (12,2)-(12,11)) + │ ├── parameters: + │ │ @ ParametersNode (location: (12,3)-(12,7)) + │ │ ├── requireds: (length: 2) + │ │ │ ├── @ RequiredParameterNode (location: (12,3)-(12,4)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ └── @ RequiredParameterNode (location: (12,6)-(12,7)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :b + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── locals: (length: 1) + │ │ └── @ BlockLocalVariableNode (location: (12,9)-(12,10)) + │ │ ├── flags: ∅ + │ │ └── name: :c + │ ├── opening_loc: (12,2)-(12,3) = "(" + │ └── closing_loc: (12,10)-(12,11) = ")" + └── body: ∅ diff --git a/test/prism/snapshots/unparser/corpus/literal/literal.txt b/test/prism/snapshots/unparser/corpus/literal/literal.txt new file mode 100644 index 0000000000..98b88e11ce --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/literal.txt @@ -0,0 +1,1198 @@ +@ ProgramNode (location: (1,0)-(91,2)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(91,2)) + └── body: (length: 78) + ├── @ HashNode (location: (1,0)-(1,38)) + │ ├── opening_loc: (1,0)-(1,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (1,2)-(1,21)) + │ │ │ ├── key: + │ │ │ │ @ StringNode (location: (1,2)-(1,7)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: (1,2)-(1,3) = "\"" + │ │ │ │ ├── content_loc: (1,3)-(1,6) = "foo" + │ │ │ │ ├── closing_loc: (1,6)-(1,7) = "\"" + │ │ │ │ └── unescaped: "foo" + │ │ │ ├── value: + │ │ │ │ @ InterpolatedStringNode (location: (1,11)-(1,21)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── opening_loc: (1,11)-(1,21) = "<<-HEREDOC" + │ │ │ │ ├── parts: (length: 3) + │ │ │ │ │ ├── @ StringNode (location: (2,0)-(2,2)) + │ │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── content_loc: (2,0)-(2,2) = " " + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── unescaped: " " + │ │ │ │ │ ├── @ EmbeddedStatementsNode (location: (2,2)-(2,5)) + │ │ │ │ │ │ ├── opening_loc: (2,2)-(2,4) = "\#{" + │ │ │ │ │ │ ├── statements: ∅ + │ │ │ │ │ │ └── closing_loc: (2,4)-(2,5) = "}" + │ │ │ │ │ └── @ StringNode (location: (2,5)-(3,0)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (2,5)-(3,0) = "\n" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "\n" + │ │ │ │ └── closing_loc: (3,0)-(4,0) = "HEREDOC\n" + │ │ │ └── operator_loc: (1,8)-(1,10) = "=>" + │ │ └── @ AssocNode (location: (1,23)-(1,36)) + │ │ ├── key: + │ │ │ @ StringNode (location: (1,23)-(1,28)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (1,23)-(1,24) = "\"" + │ │ │ ├── content_loc: (1,24)-(1,27) = "bar" + │ │ │ ├── closing_loc: (1,27)-(1,28) = "\"" + │ │ │ └── unescaped: "bar" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (1,32)-(1,36)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (1,32)-(1,33) = ":" + │ │ │ ├── value_loc: (1,33)-(1,36) = "baz" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "baz" + │ │ └── operator_loc: (1,29)-(1,31) = "=>" + │ └── closing_loc: (1,37)-(1,38) = "}" + ├── @ HashNode (location: (4,0)-(4,31)) + │ ├── opening_loc: (4,0)-(4,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (4,2)-(4,14)) + │ │ │ ├── key: + │ │ │ │ @ StringNode (location: (4,2)-(4,7)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: (4,2)-(4,3) = "\"" + │ │ │ │ ├── content_loc: (4,3)-(4,6) = "foo" + │ │ │ │ ├── closing_loc: (4,6)-(4,7) = "\"" + │ │ │ │ └── unescaped: "foo" + │ │ │ ├── value: + │ │ │ │ @ StringNode (location: (4,11)-(4,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── opening_loc: (4,11)-(4,13) = "%(" + │ │ │ │ ├── content_loc: (4,13)-(4,13) = "" + │ │ │ │ ├── closing_loc: (4,13)-(4,14) = ")" + │ │ │ │ └── unescaped: "" + │ │ │ └── operator_loc: (4,8)-(4,10) = "=>" + │ │ └── @ AssocNode (location: (4,16)-(4,29)) + │ │ ├── key: + │ │ │ @ StringNode (location: (4,16)-(4,21)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (4,16)-(4,17) = "\"" + │ │ │ ├── content_loc: (4,17)-(4,20) = "bar" + │ │ │ ├── closing_loc: (4,20)-(4,21) = "\"" + │ │ │ └── unescaped: "bar" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (4,25)-(4,29)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (4,25)-(4,26) = ":" + │ │ │ ├── value_loc: (4,26)-(4,29) = "baz" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "baz" + │ │ └── operator_loc: (4,22)-(4,24) = "=>" + │ └── closing_loc: (4,30)-(4,31) = "}" + ├── @ ArrayNode (location: (5,0)-(5,12)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ StringNode (location: (5,1)-(5,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (5,1)-(5,2) = "\"" + │ │ │ ├── content_loc: (5,2)-(5,5) = "foo" + │ │ │ ├── closing_loc: (5,5)-(5,6) = "\"" + │ │ │ └── unescaped: "foo" + │ │ └── @ StringNode (location: (5,8)-(5,11)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (5,8)-(5,10) = "%(" + │ │ ├── content_loc: (5,10)-(5,10) = "" + │ │ ├── closing_loc: (5,10)-(5,11) = ")" + │ │ └── unescaped: "" + │ ├── opening_loc: (5,0)-(5,1) = "[" + │ └── closing_loc: (5,11)-(5,12) = "]" + ├── @ CallNode (location: (6,0)-(6,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (6,0)-(6,13)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (6,0)-(6,1) = "a" + │ │ ├── opening_loc: (6,1)-(6,2) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (6,2)-(6,12)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ InterpolatedStringNode (location: (6,2)-(6,12)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (6,2)-(6,12) = "<<-HEREDOC" + │ │ │ ├── parts: (length: 3) + │ │ │ │ ├── @ StringNode (location: (7,0)-(7,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (7,0)-(7,2) = " " + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: " " + │ │ │ │ ├── @ EmbeddedStatementsNode (location: (7,2)-(7,5)) + │ │ │ │ │ ├── opening_loc: (7,2)-(7,4) = "\#{" + │ │ │ │ │ ├── statements: ∅ + │ │ │ │ │ └── closing_loc: (7,4)-(7,5) = "}" + │ │ │ │ └── @ StringNode (location: (7,5)-(8,0)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (7,5)-(8,0) = "\n" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "\n" + │ │ │ └── closing_loc: (8,0)-(9,0) = "HEREDOC\n" + │ │ ├── closing_loc: (6,12)-(6,13) = ")" + │ │ └── block: ∅ + │ ├── call_operator_loc: (6,13)-(6,14) = "." + │ ├── name: :a + │ ├── message_loc: (6,14)-(6,15) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (9,0)-(9,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (9,0)-(9,6)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (9,0)-(9,1) = "a" + │ │ ├── opening_loc: (9,1)-(9,2) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (9,2)-(9,5)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (9,2)-(9,5)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (9,2)-(9,4) = "%(" + │ │ │ ├── content_loc: (9,4)-(9,4) = "" + │ │ │ ├── closing_loc: (9,4)-(9,5) = ")" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: (9,5)-(9,6) = ")" + │ │ └── block: ∅ + │ ├── call_operator_loc: (9,6)-(9,7) = "." + │ ├── name: :a + │ ├── message_loc: (9,7)-(9,8) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ HashNode (location: (10,0)-(10,30)) + │ ├── opening_loc: (10,0)-(10,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (10,2)-(10,21)) + │ │ │ ├── key: + │ │ │ │ @ StringNode (location: (10,2)-(10,7)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: (10,2)-(10,3) = "\"" + │ │ │ │ ├── content_loc: (10,3)-(10,6) = "foo" + │ │ │ │ ├── closing_loc: (10,6)-(10,7) = "\"" + │ │ │ │ └── unescaped: "foo" + │ │ │ ├── value: + │ │ │ │ @ InterpolatedStringNode (location: (10,11)-(10,21)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── opening_loc: (10,11)-(10,21) = "<<-HEREDOC" + │ │ │ │ ├── parts: (length: 3) + │ │ │ │ │ ├── @ StringNode (location: (11,0)-(11,2)) + │ │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── content_loc: (11,0)-(11,2) = " " + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── unescaped: " " + │ │ │ │ │ ├── @ EmbeddedStatementsNode (location: (11,2)-(11,5)) + │ │ │ │ │ │ ├── opening_loc: (11,2)-(11,4) = "\#{" + │ │ │ │ │ │ ├── statements: ∅ + │ │ │ │ │ │ └── closing_loc: (11,4)-(11,5) = "}" + │ │ │ │ │ └── @ StringNode (location: (11,5)-(12,0)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (11,5)-(12,0) = "\n" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "\n" + │ │ │ │ └── closing_loc: (12,0)-(13,0) = "HEREDOC\n" + │ │ │ └── operator_loc: (10,8)-(10,10) = "=>" + │ │ └── @ AssocSplatNode (location: (10,23)-(10,28)) + │ │ ├── value: + │ │ │ @ CallNode (location: (10,25)-(10,28)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (10,25)-(10,28) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (10,23)-(10,25) = "**" + │ └── closing_loc: (10,29)-(10,30) = "}" + ├── @ HashNode (location: (13,0)-(13,23)) + │ ├── opening_loc: (13,0)-(13,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (13,2)-(13,14)) + │ │ │ ├── key: + │ │ │ │ @ StringNode (location: (13,2)-(13,7)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: (13,2)-(13,3) = "\"" + │ │ │ │ ├── content_loc: (13,3)-(13,6) = "foo" + │ │ │ │ ├── closing_loc: (13,6)-(13,7) = "\"" + │ │ │ │ └── unescaped: "foo" + │ │ │ ├── value: + │ │ │ │ @ StringNode (location: (13,11)-(13,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── opening_loc: (13,11)-(13,13) = "%(" + │ │ │ │ ├── content_loc: (13,13)-(13,13) = "" + │ │ │ │ ├── closing_loc: (13,13)-(13,14) = ")" + │ │ │ │ └── unescaped: "" + │ │ │ └── operator_loc: (13,8)-(13,10) = "=>" + │ │ └── @ AssocSplatNode (location: (13,16)-(13,21)) + │ │ ├── value: + │ │ │ @ CallNode (location: (13,18)-(13,21)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (13,18)-(13,21) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (13,16)-(13,18) = "**" + │ └── closing_loc: (13,22)-(13,23) = "}" + ├── @ InterpolatedStringNode (location: (14,0)-(14,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (14,0)-(14,1) = "\"" + │ ├── parts: (length: 5) + │ │ ├── @ EmbeddedVariableNode (location: (14,1)-(14,4)) + │ │ │ ├── operator_loc: (14,1)-(14,2) = "#" + │ │ │ └── variable: + │ │ │ @ InstanceVariableReadNode (location: (14,2)-(14,4)) + │ │ │ └── name: :@a + │ │ ├── @ StringNode (location: (14,4)-(14,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (14,4)-(14,5) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ ├── @ EmbeddedVariableNode (location: (14,5)-(14,9)) + │ │ │ ├── operator_loc: (14,5)-(14,6) = "#" + │ │ │ └── variable: + │ │ │ @ ClassVariableReadNode (location: (14,6)-(14,9)) + │ │ │ └── name: :@@a + │ │ ├── @ StringNode (location: (14,9)-(14,10)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (14,9)-(14,10) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ └── @ EmbeddedVariableNode (location: (14,10)-(14,13)) + │ │ ├── operator_loc: (14,10)-(14,11) = "#" + │ │ └── variable: + │ │ @ GlobalVariableReadNode (location: (14,11)-(14,13)) + │ │ └── name: :$a + │ └── closing_loc: (14,13)-(14,14) = "\"" + ├── @ IntegerNode (location: (15,0)-(15,1)) + │ ├── flags: decimal + │ └── value: 0 + ├── @ CallNode (location: (16,0)-(16,3)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ IntegerNode (location: (16,1)-(16,3)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── call_operator_loc: ∅ + │ ├── name: :+@ + │ ├── message_loc: (16,0)-(16,1) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ IntegerNode (location: (17,0)-(17,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ IntegerNode (location: (18,0)-(18,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ RationalNode (location: (19,0)-(19,2)) + │ └── numeric: + │ @ IntegerNode (location: (19,0)-(19,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ RationalNode (location: (20,0)-(20,4)) + │ └── numeric: + │ @ FloatNode (location: (20,0)-(20,3)) + │ └── value: 1.5 + ├── @ RationalNode (location: (21,0)-(21,4)) + │ └── numeric: + │ @ FloatNode (location: (21,0)-(21,3)) + │ └── value: 1.3 + ├── @ ImaginaryNode (location: (22,0)-(22,2)) + │ └── numeric: + │ @ IntegerNode (location: (22,0)-(22,1)) + │ ├── flags: decimal + │ └── value: 5 + ├── @ ImaginaryNode (location: (23,0)-(23,3)) + │ └── numeric: + │ @ IntegerNode (location: (23,0)-(23,2)) + │ ├── flags: decimal + │ └── value: -5 + ├── @ ImaginaryNode (location: (24,0)-(24,4)) + │ └── numeric: + │ @ FloatNode (location: (24,0)-(24,3)) + │ └── value: 0.6 + ├── @ ImaginaryNode (location: (25,0)-(25,5)) + │ └── numeric: + │ @ FloatNode (location: (25,0)-(25,4)) + │ └── value: -0.6 + ├── @ ImaginaryNode (location: (26,0)-(26,32)) + │ └── numeric: + │ @ IntegerNode (location: (26,0)-(26,31)) + │ ├── flags: decimal + │ └── value: 1000000000000000000000000000000 + ├── @ ImaginaryNode (location: (27,0)-(27,3)) + │ └── numeric: + │ @ RationalNode (location: (27,0)-(27,2)) + │ └── numeric: + │ @ IntegerNode (location: (27,0)-(27,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── @ InterpolatedStringNode (location: (28,0)-(28,11)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (28,0)-(28,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (28,0)-(28,1) = "\"" + │ │ │ ├── content_loc: (28,1)-(28,4) = "foo" + │ │ │ ├── closing_loc: (28,4)-(28,5) = "\"" + │ │ │ └── unescaped: "foo" + │ │ └── @ StringNode (location: (28,6)-(28,11)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (28,6)-(28,7) = "\"" + │ │ ├── content_loc: (28,7)-(28,10) = "bar" + │ │ ├── closing_loc: (28,10)-(28,11) = "\"" + │ │ └── unescaped: "bar" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (29,0)-(29,15)) + │ ├── flags: ∅ + │ ├── opening_loc: (29,0)-(29,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (29,1)-(29,8)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (29,1)-(29,8) = "foobar " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foobar " + │ │ └── @ EmbeddedStatementsNode (location: (29,8)-(29,14)) + │ │ ├── opening_loc: (29,8)-(29,10) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (29,10)-(29,13)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (29,10)-(29,13)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :baz + │ │ │ ├── message_loc: (29,10)-(29,13) = "baz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── closing_loc: (29,13)-(29,14) = "}" + │ └── closing_loc: (29,14)-(29,15) = "\"" + ├── @ InterpolatedStringNode (location: (30,0)-(30,12)) + │ ├── flags: ∅ + │ ├── opening_loc: (30,0)-(30,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (30,1)-(30,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (30,1)-(30,4) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ ├── @ EmbeddedStatementsNode (location: (30,4)-(30,8)) + │ │ │ ├── opening_loc: (30,4)-(30,6) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (30,6)-(30,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (30,6)-(30,7)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── closing_loc: (30,7)-(30,8) = "}" + │ │ └── @ StringNode (location: (30,8)-(30,11)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (30,8)-(30,11) = "bar" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "bar" + │ └── closing_loc: (30,11)-(30,12) = "\"" + ├── @ InterpolatedStringNode (location: (31,0)-(31,9)) + │ ├── flags: ∅ + │ ├── opening_loc: (31,0)-(31,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (31,1)-(31,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (31,1)-(31,5) = "\\\\\\\\" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\\\\" + │ │ └── @ EmbeddedStatementsNode (location: (31,5)-(31,8)) + │ │ ├── opening_loc: (31,5)-(31,7) = "\#{" + │ │ ├── statements: ∅ + │ │ └── closing_loc: (31,7)-(31,8) = "}" + │ └── closing_loc: (31,8)-(31,9) = "\"" + ├── @ InterpolatedStringNode (location: (32,0)-(32,9)) + │ ├── flags: ∅ + │ ├── opening_loc: (32,0)-(32,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (32,1)-(32,4)) + │ │ │ ├── opening_loc: (32,1)-(32,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (32,3)-(32,4) = "}" + │ │ └── @ StringNode (location: (32,4)-(32,8)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (32,4)-(32,8) = "\\\#{}" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\#{}" + │ └── closing_loc: (32,8)-(32,9) = "\"" + ├── @ InterpolatedStringNode (location: (33,0)-(33,9)) + │ ├── flags: ∅ + │ ├── opening_loc: (33,0)-(33,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (33,1)-(33,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (33,1)-(33,5) = "\\\#{}" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\#{}" + │ │ └── @ EmbeddedStatementsNode (location: (33,5)-(33,8)) + │ │ ├── opening_loc: (33,5)-(33,7) = "\#{" + │ │ ├── statements: ∅ + │ │ └── closing_loc: (33,7)-(33,8) = "}" + │ └── closing_loc: (33,8)-(33,9) = "\"" + ├── @ StringNode (location: (34,0)-(34,15)) + │ ├── flags: ∅ + │ ├── opening_loc: (34,0)-(34,1) = "\"" + │ ├── content_loc: (34,1)-(34,14) = "foo\\\\\\\#{@bar}" + │ ├── closing_loc: (34,14)-(34,15) = "\"" + │ └── unescaped: "foo\\\#{@bar}" + ├── @ StringNode (location: (35,0)-(35,4)) + │ ├── flags: ∅ + │ ├── opening_loc: (35,0)-(35,1) = "\"" + │ ├── content_loc: (35,1)-(35,3) = "\\\"" + │ ├── closing_loc: (35,3)-(35,4) = "\"" + │ └── unescaped: "\"" + ├── @ StringNode (location: (36,0)-(36,9)) + │ ├── flags: ∅ + │ ├── opening_loc: (36,0)-(36,1) = "\"" + │ ├── content_loc: (36,1)-(36,8) = "foo bar" + │ ├── closing_loc: (36,8)-(36,9) = "\"" + │ └── unescaped: "foo bar" + ├── @ StringNode (location: (37,0)-(37,10)) + │ ├── flags: ∅ + │ ├── opening_loc: (37,0)-(37,1) = "\"" + │ ├── content_loc: (37,1)-(37,9) = "foo\\nbar" + │ ├── closing_loc: (37,9)-(37,10) = "\"" + │ └── unescaped: "foo\nbar" + ├── @ XStringNode (location: (38,0)-(38,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (38,0)-(38,1) = "`" + │ ├── content_loc: (38,1)-(38,4) = "foo" + │ ├── closing_loc: (38,4)-(38,5) = "`" + │ └── unescaped: "foo" + ├── @ InterpolatedXStringNode (location: (39,0)-(39,12)) + │ ├── opening_loc: (39,0)-(39,1) = "`" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (39,1)-(39,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (39,1)-(39,4) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ └── @ EmbeddedStatementsNode (location: (39,4)-(39,11)) + │ │ ├── opening_loc: (39,4)-(39,6) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (39,6)-(39,10)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ InstanceVariableReadNode (location: (39,6)-(39,10)) + │ │ │ └── name: :@bar + │ │ └── closing_loc: (39,10)-(39,11) = "}" + │ └── closing_loc: (39,11)-(39,12) = "`" + ├── @ XStringNode (location: (40,0)-(40,3)) + │ ├── flags: ∅ + │ ├── opening_loc: (40,0)-(40,1) = "`" + │ ├── content_loc: (40,1)-(40,2) = ")" + │ ├── closing_loc: (40,2)-(40,3) = "`" + │ └── unescaped: ")" + ├── @ XStringNode (location: (41,0)-(41,4)) + │ ├── flags: ∅ + │ ├── opening_loc: (41,0)-(41,1) = "`" + │ ├── content_loc: (41,1)-(41,3) = "\\`" + │ ├── closing_loc: (41,3)-(41,4) = "`" + │ └── unescaped: "`" + ├── @ XStringNode (location: (42,0)-(42,3)) + │ ├── flags: ∅ + │ ├── opening_loc: (42,0)-(42,1) = "`" + │ ├── content_loc: (42,1)-(42,2) = "\"" + │ ├── closing_loc: (42,2)-(42,3) = "`" + │ └── unescaped: "\"" + ├── @ SymbolNode (location: (43,0)-(43,4)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (43,0)-(43,1) = ":" + │ ├── value_loc: (43,1)-(43,4) = "foo" + │ ├── closing_loc: ∅ + │ └── unescaped: "foo" + ├── @ SymbolNode (location: (44,0)-(44,6)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (44,0)-(44,2) = ":\"" + │ ├── value_loc: (44,2)-(44,5) = "A B" + │ ├── closing_loc: (44,5)-(44,6) = "\"" + │ └── unescaped: "A B" + ├── @ SymbolNode (location: (45,0)-(45,4)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (45,0)-(45,1) = ":" + │ ├── value_loc: (45,1)-(45,4) = "foo" + │ ├── closing_loc: ∅ + │ └── unescaped: "foo" + ├── @ SymbolNode (location: (46,0)-(46,6)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (46,0)-(46,2) = ":\"" + │ ├── value_loc: (46,2)-(46,5) = "A B" + │ ├── closing_loc: (46,5)-(46,6) = "\"" + │ └── unescaped: "A B" + ├── @ SymbolNode (location: (47,0)-(47,7)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (47,0)-(47,2) = ":\"" + │ ├── value_loc: (47,2)-(47,6) = "A\\\"B" + │ ├── closing_loc: (47,6)-(47,7) = "\"" + │ └── unescaped: "A\"B" + ├── @ SymbolNode (location: (48,0)-(48,3)) + │ ├── flags: ∅ + │ ├── opening_loc: (48,0)-(48,2) = ":\"" + │ ├── value_loc: (1,0)-(1,0) = "" + │ ├── closing_loc: (48,2)-(48,3) = "\"" + │ └── unescaped: "" + ├── @ RegularExpressionNode (location: (49,0)-(49,5)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (49,0)-(49,1) = "/" + │ ├── content_loc: (49,1)-(49,4) = "foo" + │ ├── closing_loc: (49,4)-(49,5) = "/" + │ └── unescaped: "foo" + ├── @ RegularExpressionNode (location: (50,0)-(50,28)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (50,0)-(50,1) = "/" + │ ├── content_loc: (50,1)-(50,27) = "[^-+',.\\/:@[:alnum:]\\[\\]]+" + │ ├── closing_loc: (50,27)-(50,28) = "/" + │ └── unescaped: "[^-+',./:@[:alnum:]\\[\\]]+" + ├── @ InterpolatedRegularExpressionNode (location: (51,0)-(51,12)) + │ ├── flags: ∅ + │ ├── opening_loc: (51,0)-(51,1) = "/" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (51,1)-(51,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (51,1)-(51,4) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ └── @ EmbeddedStatementsNode (location: (51,4)-(51,11)) + │ │ ├── opening_loc: (51,4)-(51,6) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (51,6)-(51,10)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ InstanceVariableReadNode (location: (51,6)-(51,10)) + │ │ │ └── name: :@bar + │ │ └── closing_loc: (51,10)-(51,11) = "}" + │ └── closing_loc: (51,11)-(51,12) = "/" + ├── @ InterpolatedRegularExpressionNode (location: (52,0)-(52,15)) + │ ├── flags: ignore_case, extended, multi_line + │ ├── opening_loc: (52,0)-(52,1) = "/" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (52,1)-(52,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (52,1)-(52,4) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ └── @ EmbeddedStatementsNode (location: (52,4)-(52,11)) + │ │ ├── opening_loc: (52,4)-(52,6) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (52,6)-(52,10)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ InstanceVariableReadNode (location: (52,6)-(52,10)) + │ │ │ └── name: :@bar + │ │ └── closing_loc: (52,10)-(52,11) = "}" + │ └── closing_loc: (52,11)-(52,15) = "/imx" + ├── @ InterpolatedRegularExpressionNode (location: (53,0)-(53,13)) + │ ├── flags: ∅ + │ ├── opening_loc: (53,0)-(53,1) = "/" + │ ├── parts: (length: 1) + │ │ └── @ EmbeddedStatementsNode (location: (53,1)-(53,12)) + │ │ ├── opening_loc: (53,1)-(53,3) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (53,3)-(53,11)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ StringNode (location: (53,3)-(53,11)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (53,3)-(53,4) = "\"" + │ │ │ ├── content_loc: (53,4)-(53,10) = "\\u0000" + │ │ │ ├── closing_loc: (53,10)-(53,11) = "\"" + │ │ │ └── unescaped: "\u0000" + │ │ └── closing_loc: (53,11)-(53,12) = "}" + │ └── closing_loc: (53,12)-(53,13) = "/" + ├── @ RegularExpressionNode (location: (54,0)-(54,4)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (54,0)-(54,1) = "/" + │ ├── content_loc: (54,1)-(54,3) = "\\n" + │ ├── closing_loc: (54,3)-(54,4) = "/" + │ └── unescaped: "\\n" + ├── @ RegularExpressionNode (location: (55,0)-(55,4)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (55,0)-(55,1) = "/" + │ ├── content_loc: (55,1)-(55,3) = "\\n" + │ ├── closing_loc: (55,3)-(55,4) = "/" + │ └── unescaped: "\\n" + ├── @ RegularExpressionNode (location: (56,0)-(56,5)) + │ ├── flags: extended, forced_us_ascii_encoding + │ ├── opening_loc: (56,0)-(56,1) = "/" + │ ├── content_loc: (56,1)-(56,3) = "\\n" + │ ├── closing_loc: (56,3)-(56,5) = "/x" + │ └── unescaped: "\\n" + ├── @ RegularExpressionNode (location: (57,0)-(57,7)) + │ ├── flags: extended, forced_us_ascii_encoding + │ ├── opening_loc: (57,0)-(57,1) = "/" + │ ├── content_loc: (57,1)-(57,5) = "\\/\\/" + │ ├── closing_loc: (57,5)-(57,7) = "/x" + │ └── unescaped: "//" + ├── @ InterpolatedSymbolNode (location: (58,0)-(58,15)) + │ ├── opening_loc: (58,0)-(58,2) = ":\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (58,2)-(58,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (58,2)-(58,5) = "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "foo" + │ │ ├── @ EmbeddedStatementsNode (location: (58,5)-(58,11)) + │ │ │ ├── opening_loc: (58,5)-(58,7) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (58,7)-(58,10)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (58,7)-(58,10)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (58,7)-(58,10) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── closing_loc: (58,10)-(58,11) = "}" + │ │ └── @ StringNode (location: (58,11)-(58,14)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (58,11)-(58,14) = "baz" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "baz" + │ └── closing_loc: (58,14)-(58,15) = "\"" + ├── @ InterpolatedSymbolNode (location: (59,0)-(59,11)) + │ ├── opening_loc: (59,0)-(59,2) = ":\"" + │ ├── parts: (length: 1) + │ │ └── @ EmbeddedStatementsNode (location: (59,2)-(59,10)) + │ │ ├── opening_loc: (59,2)-(59,4) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (59,4)-(59,9)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ StringNode (location: (59,4)-(59,9)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (59,4)-(59,5) = "\"" + │ │ │ ├── content_loc: (59,5)-(59,8) = "foo" + │ │ │ ├── closing_loc: (59,8)-(59,9) = "\"" + │ │ │ └── unescaped: "foo" + │ │ └── closing_loc: (59,9)-(59,10) = "}" + │ └── closing_loc: (59,10)-(59,11) = "\"" + ├── @ RangeNode (location: (60,0)-(60,14)) + │ ├── flags: ∅ + │ ├── left: + │ │ @ ParenthesesNode (location: (60,0)-(60,11)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (60,1)-(60,10)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (60,1)-(60,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ FloatNode (location: (60,1)-(60,4)) + │ │ │ │ └── value: 0.0 + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :/ + │ │ │ ├── message_loc: (60,5)-(60,6) = "/" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (60,7)-(60,10)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ FloatNode (location: (60,7)-(60,10)) + │ │ │ │ └── value: 0.0 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (60,0)-(60,1) = "(" + │ │ └── closing_loc: (60,10)-(60,11) = ")" + │ ├── right: + │ │ @ IntegerNode (location: (60,13)-(60,14)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (60,11)-(60,13) = ".." + ├── @ RangeNode (location: (61,0)-(61,14)) + │ ├── flags: ∅ + │ ├── left: + │ │ @ IntegerNode (location: (61,0)-(61,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── right: + │ │ @ ParenthesesNode (location: (61,3)-(61,14)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (61,4)-(61,13)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (61,4)-(61,13)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ FloatNode (location: (61,4)-(61,7)) + │ │ │ │ └── value: 0.0 + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :/ + │ │ │ ├── message_loc: (61,8)-(61,9) = "/" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (61,10)-(61,13)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ FloatNode (location: (61,10)-(61,13)) + │ │ │ │ └── value: 0.0 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (61,3)-(61,4) = "(" + │ │ └── closing_loc: (61,13)-(61,14) = ")" + │ └── operator_loc: (61,1)-(61,3) = ".." + ├── @ RangeNode (location: (62,0)-(62,16)) + │ ├── flags: ∅ + │ ├── left: + │ │ @ ParenthesesNode (location: (62,0)-(62,11)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (62,1)-(62,10)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (62,1)-(62,10)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ FloatNode (location: (62,1)-(62,4)) + │ │ │ │ └── value: 0.0 + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :/ + │ │ │ ├── message_loc: (62,5)-(62,6) = "/" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (62,7)-(62,10)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ FloatNode (location: (62,7)-(62,10)) + │ │ │ │ └── value: 0.0 + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (62,0)-(62,1) = "(" + │ │ └── closing_loc: (62,10)-(62,11) = ")" + │ ├── right: + │ │ @ IntegerNode (location: (62,13)-(62,16)) + │ │ ├── flags: decimal + │ │ └── value: 100 + │ └── operator_loc: (62,11)-(62,13) = ".." + ├── @ FloatNode (location: (63,0)-(63,4)) + │ └── value: -0.1 + ├── @ FloatNode (location: (64,0)-(64,3)) + │ └── value: 0.1 + ├── @ ArrayNode (location: (65,0)-(65,6)) + │ ├── flags: ∅ + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (65,1)-(65,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (65,4)-(65,5)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── opening_loc: (65,0)-(65,1) = "[" + │ └── closing_loc: (65,5)-(65,6) = "]" + ├── @ ArrayNode (location: (66,0)-(66,11)) + │ ├── flags: ∅ + │ ├── elements: (length: 3) + │ │ ├── @ IntegerNode (location: (66,1)-(66,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── @ ParenthesesNode (location: (66,4)-(66,6)) + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (66,4)-(66,5) = "(" + │ │ │ └── closing_loc: (66,5)-(66,6) = ")" + │ │ └── @ CallNode (location: (66,8)-(66,10)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :n2 + │ │ ├── message_loc: (66,8)-(66,10) = "n2" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (66,0)-(66,1) = "[" + │ └── closing_loc: (66,10)-(66,11) = "]" + ├── @ ArrayNode (location: (67,0)-(67,3)) + │ ├── flags: ∅ + │ ├── elements: (length: 1) + │ │ └── @ IntegerNode (location: (67,1)-(67,2)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── opening_loc: (67,0)-(67,1) = "[" + │ └── closing_loc: (67,2)-(67,3) = "]" + ├── @ ArrayNode (location: (68,0)-(68,2)) + │ ├── flags: ∅ + │ ├── elements: (length: 0) + │ ├── opening_loc: (68,0)-(68,1) = "[" + │ └── closing_loc: (68,1)-(68,2) = "]" + ├── @ ArrayNode (location: (69,0)-(69,10)) + │ ├── flags: contains_splat + │ ├── elements: (length: 2) + │ │ ├── @ IntegerNode (location: (69,1)-(69,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ SplatNode (location: (69,4)-(69,9)) + │ │ ├── operator_loc: (69,4)-(69,5) = "*" + │ │ └── expression: + │ │ @ InstanceVariableReadNode (location: (69,5)-(69,9)) + │ │ └── name: :@foo + │ ├── opening_loc: (69,0)-(69,1) = "[" + │ └── closing_loc: (69,9)-(69,10) = "]" + ├── @ ArrayNode (location: (70,0)-(70,10)) + │ ├── flags: contains_splat + │ ├── elements: (length: 2) + │ │ ├── @ SplatNode (location: (70,1)-(70,6)) + │ │ │ ├── operator_loc: (70,1)-(70,2) = "*" + │ │ │ └── expression: + │ │ │ @ InstanceVariableReadNode (location: (70,2)-(70,6)) + │ │ │ └── name: :@foo + │ │ └── @ IntegerNode (location: (70,8)-(70,9)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── opening_loc: (70,0)-(70,1) = "[" + │ └── closing_loc: (70,9)-(70,10) = "]" + ├── @ ArrayNode (location: (71,0)-(71,14)) + │ ├── flags: contains_splat + │ ├── elements: (length: 2) + │ │ ├── @ SplatNode (location: (71,1)-(71,6)) + │ │ │ ├── operator_loc: (71,1)-(71,2) = "*" + │ │ │ └── expression: + │ │ │ @ InstanceVariableReadNode (location: (71,2)-(71,6)) + │ │ │ └── name: :@foo + │ │ └── @ SplatNode (location: (71,8)-(71,13)) + │ │ ├── operator_loc: (71,8)-(71,9) = "*" + │ │ └── expression: + │ │ @ InstanceVariableReadNode (location: (71,9)-(71,13)) + │ │ └── name: :@baz + │ ├── opening_loc: (71,0)-(71,1) = "[" + │ └── closing_loc: (71,13)-(71,14) = "]" + ├── @ HashNode (location: (72,0)-(72,2)) + │ ├── opening_loc: (72,0)-(72,1) = "{" + │ ├── elements: (length: 0) + │ └── closing_loc: (72,1)-(72,2) = "}" + ├── @ HashNode (location: (73,0)-(73,12)) + │ ├── opening_loc: (73,0)-(73,1) = "{" + │ ├── elements: (length: 1) + │ │ └── @ AssocNode (location: (73,2)-(73,10)) + │ │ ├── key: + │ │ │ @ ParenthesesNode (location: (73,2)-(73,4)) + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (73,2)-(73,3) = "(" + │ │ │ └── closing_loc: (73,3)-(73,4) = ")" + │ │ ├── value: + │ │ │ @ ParenthesesNode (location: (73,8)-(73,10)) + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (73,8)-(73,9) = "(" + │ │ │ └── closing_loc: (73,9)-(73,10) = ")" + │ │ └── operator_loc: (73,5)-(73,7) = "=>" + │ └── closing_loc: (73,11)-(73,12) = "}" + ├── @ HashNode (location: (74,0)-(74,10)) + │ ├── opening_loc: (74,0)-(74,1) = "{" + │ ├── elements: (length: 1) + │ │ └── @ AssocNode (location: (74,2)-(74,8)) + │ │ ├── key: + │ │ │ @ IntegerNode (location: (74,2)-(74,3)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── value: + │ │ │ @ IntegerNode (location: (74,7)-(74,8)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: (74,4)-(74,6) = "=>" + │ └── closing_loc: (74,9)-(74,10) = "}" + ├── @ HashNode (location: (75,0)-(75,18)) + │ ├── opening_loc: (75,0)-(75,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (75,2)-(75,8)) + │ │ │ ├── key: + │ │ │ │ @ IntegerNode (location: (75,2)-(75,3)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── value: + │ │ │ │ @ IntegerNode (location: (75,7)-(75,8)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ └── operator_loc: (75,4)-(75,6) = "=>" + │ │ └── @ AssocNode (location: (75,10)-(75,16)) + │ │ ├── key: + │ │ │ @ IntegerNode (location: (75,10)-(75,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 3 + │ │ ├── value: + │ │ │ @ IntegerNode (location: (75,15)-(75,16)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 4 + │ │ └── operator_loc: (75,12)-(75,14) = "=>" + │ └── closing_loc: (75,17)-(75,18) = "}" + ├── @ HashNode (location: (76,0)-(76,27)) + │ ├── opening_loc: (76,0)-(76,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (76,2)-(76,19)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (76,2)-(76,4)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (76,2)-(76,3) = "a" + │ │ │ │ ├── closing_loc: (76,3)-(76,4) = ":" + │ │ │ │ └── unescaped: "a" + │ │ │ ├── value: + │ │ │ │ @ ParenthesesNode (location: (76,5)-(76,19)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (76,6)-(76,18)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ RescueModifierNode (location: (76,6)-(76,18)) + │ │ │ │ │ ├── expression: + │ │ │ │ │ │ @ IntegerNode (location: (76,6)-(76,7)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 1 + │ │ │ │ │ ├── keyword_loc: (76,8)-(76,14) = "rescue" + │ │ │ │ │ └── rescue_expression: + │ │ │ │ │ @ CallNode (location: (76,15)-(76,18)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :foo + │ │ │ │ │ ├── message_loc: (76,15)-(76,18) = "foo" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ ├── opening_loc: (76,5)-(76,6) = "(" + │ │ │ │ └── closing_loc: (76,18)-(76,19) = ")" + │ │ │ └── operator_loc: ∅ + │ │ └── @ AssocNode (location: (76,21)-(76,25)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (76,21)-(76,23)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (76,21)-(76,22) = "b" + │ │ │ ├── closing_loc: (76,22)-(76,23) = ":" + │ │ │ └── unescaped: "b" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (76,24)-(76,25)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: ∅ + │ └── closing_loc: (76,26)-(76,27) = "}" + ├── @ HashNode (location: (77,0)-(77,14)) + │ ├── opening_loc: (77,0)-(77,1) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (77,2)-(77,6)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (77,2)-(77,4)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (77,2)-(77,3) = "a" + │ │ │ │ ├── closing_loc: (77,3)-(77,4) = ":" + │ │ │ │ └── unescaped: "a" + │ │ │ ├── value: + │ │ │ │ @ IntegerNode (location: (77,5)-(77,6)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── operator_loc: ∅ + │ │ └── @ AssocNode (location: (77,8)-(77,12)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (77,8)-(77,10)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (77,8)-(77,9) = "b" + │ │ │ ├── closing_loc: (77,9)-(77,10) = ":" + │ │ │ └── unescaped: "b" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (77,11)-(77,12)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ └── operator_loc: ∅ + │ └── closing_loc: (77,13)-(77,14) = "}" + ├── @ HashNode (location: (78,0)-(78,9)) + │ ├── opening_loc: (78,0)-(78,1) = "{" + │ ├── elements: (length: 1) + │ │ └── @ AssocNode (location: (78,2)-(78,7)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (78,2)-(78,4)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (78,2)-(78,3) = "a" + │ │ │ ├── closing_loc: (78,3)-(78,4) = ":" + │ │ │ └── unescaped: "a" + │ │ ├── value: + │ │ │ @ SymbolNode (location: (78,5)-(78,7)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (78,5)-(78,6) = ":" + │ │ │ ├── value_loc: (78,6)-(78,7) = "a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a" + │ │ └── operator_loc: ∅ + │ └── closing_loc: (78,8)-(78,9) = "}" + ├── @ HashNode (location: (79,0)-(79,15)) + │ ├── opening_loc: (79,0)-(79,1) = "{" + │ ├── elements: (length: 1) + │ │ └── @ AssocNode (location: (79,2)-(79,13)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (79,2)-(79,8)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (79,2)-(79,4) = ":\"" + │ │ │ ├── value_loc: (79,4)-(79,7) = "a b" + │ │ │ ├── closing_loc: (79,7)-(79,8) = "\"" + │ │ │ └── unescaped: "a b" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (79,12)-(79,13)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── operator_loc: (79,9)-(79,11) = "=>" + │ └── closing_loc: (79,14)-(79,15) = "}" + ├── @ HashNode (location: (80,0)-(80,12)) + │ ├── opening_loc: (80,0)-(80,1) = "{" + │ ├── elements: (length: 1) + │ │ └── @ AssocNode (location: (80,2)-(80,10)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (80,2)-(80,5)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (80,2)-(80,3) = ":" + │ │ │ ├── value_loc: (80,3)-(80,5) = "-@" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "-@" + │ │ ├── value: + │ │ │ @ IntegerNode (location: (80,9)-(80,10)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── operator_loc: (80,6)-(80,8) = "=>" + │ └── closing_loc: (80,11)-(80,12) = "}" + ├── @ InterpolatedStringNode (location: (81,0)-(82,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (81,0)-(81,1) = "\"" + │ ├── parts: (length: 4) + │ │ ├── @ EmbeddedStatementsNode (location: (81,1)-(81,4)) + │ │ │ ├── opening_loc: (81,1)-(81,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (81,3)-(81,4) = "}" + │ │ ├── @ StringNode (location: (81,4)-(82,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (81,4)-(82,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ ├── @ EmbeddedStatementsNode (location: (82,0)-(82,3)) + │ │ │ ├── opening_loc: (82,0)-(82,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (82,2)-(82,3) = "}" + │ │ └── @ StringNode (location: (82,3)-(82,6)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (82,3)-(82,6) = "\\na" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\na" + │ └── closing_loc: (82,6)-(82,7) = "\"" + ├── @ CallNode (location: (83,0)-(86,1)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (83,0)-(83,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (83,4)-(86,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (84,2)-(85,7)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (84,2)-(85,7)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (84,2)-(84,3) = "\"" + │ │ ├── parts: (length: 4) + │ │ │ ├── @ EmbeddedStatementsNode (location: (84,3)-(84,6)) + │ │ │ │ ├── opening_loc: (84,3)-(84,5) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (84,5)-(84,6) = "}" + │ │ │ ├── @ StringNode (location: (84,6)-(85,0)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (84,6)-(85,0) = "\n" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "\n" + │ │ │ ├── @ EmbeddedStatementsNode (location: (85,0)-(85,3)) + │ │ │ │ ├── opening_loc: (85,0)-(85,2) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (85,2)-(85,3) = "}" + │ │ │ └── @ StringNode (location: (85,3)-(85,6)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (85,3)-(85,6) = "\\na" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\na" + │ │ └── closing_loc: (85,6)-(85,7) = "\"" + │ ├── opening_loc: (83,4)-(83,5) = "{" + │ └── closing_loc: (86,0)-(86,1) = "}" + ├── @ SymbolNode (location: (87,0)-(88,2)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (87,0)-(87,2) = ":\"" + │ ├── value_loc: (87,2)-(88,1) = "a\\\\\nb" + │ ├── closing_loc: (88,1)-(88,2) = "\"" + │ └── unescaped: "a\\\nb" + └── @ InterpolatedXStringNode (location: (89,0)-(91,2)) + ├── opening_loc: (89,0)-(89,1) = "`" + ├── parts: (length: 3) + │ ├── @ StringNode (location: (89,1)-(90,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (89,1)-(90,0) = " x\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: " x\n" + │ ├── @ EmbeddedStatementsNode (location: (90,0)-(90,6)) + │ │ ├── opening_loc: (90,0)-(90,2) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (90,2)-(90,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (90,2)-(90,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (90,2)-(90,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── closing_loc: (90,5)-(90,6) = "}" + │ └── @ StringNode (location: (90,6)-(91,1)) + │ ├── flags: frozen + │ ├── opening_loc: ∅ + │ ├── content_loc: (90,6)-(91,1) = "\n#" + │ ├── closing_loc: ∅ + │ └── unescaped: "\n#" + └── closing_loc: (91,1)-(91,2) = "`" diff --git a/test/prism/snapshots/unparser/corpus/literal/module.txt b/test/prism/snapshots/unparser/corpus/literal/module.txt new file mode 100644 index 0000000000..6428aeea82 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/module.txt @@ -0,0 +1,104 @@ +@ ProgramNode (location: (1,0)-(16,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(16,3)) + └── body: (length: 4) + ├── @ ModuleNode (location: (1,0)-(2,3)) + │ ├── locals: [] + │ ├── module_keyword_loc: (1,0)-(1,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (1,7)-(1,8)) + │ │ └── name: :A + │ ├── body: ∅ + │ ├── end_keyword_loc: (2,0)-(2,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (4,0)-(5,3)) + │ ├── locals: [] + │ ├── module_keyword_loc: (4,0)-(4,6) = "module" + │ ├── constant_path: + │ │ @ ConstantPathNode (location: (4,7)-(4,11)) + │ │ ├── parent: + │ │ │ @ ConstantReadNode (location: (4,7)-(4,8)) + │ │ │ └── name: :A + │ │ ├── name: :B + │ │ ├── delimiter_loc: (4,8)-(4,10) = "::" + │ │ └── name_loc: (4,10)-(4,11) = "B" + │ ├── body: ∅ + │ ├── end_keyword_loc: (5,0)-(5,3) = "end" + │ └── name: :B + ├── @ ModuleNode (location: (7,0)-(8,3)) + │ ├── locals: [] + │ ├── module_keyword_loc: (7,0)-(7,6) = "module" + │ ├── constant_path: + │ │ @ ConstantPathNode (location: (7,7)-(7,14)) + │ │ ├── parent: + │ │ │ @ ConstantPathNode (location: (7,7)-(7,11)) + │ │ │ ├── parent: + │ │ │ │ @ ConstantReadNode (location: (7,7)-(7,8)) + │ │ │ │ └── name: :A + │ │ │ ├── name: :B + │ │ │ ├── delimiter_loc: (7,8)-(7,10) = "::" + │ │ │ └── name_loc: (7,10)-(7,11) = "B" + │ │ ├── name: :C + │ │ ├── delimiter_loc: (7,11)-(7,13) = "::" + │ │ └── name_loc: (7,13)-(7,14) = "C" + │ ├── body: ∅ + │ ├── end_keyword_loc: (8,0)-(8,3) = "end" + │ └── name: :C + └── @ ModuleNode (location: (10,0)-(16,3)) + ├── locals: [] + ├── module_keyword_loc: (10,0)-(10,6) = "module" + ├── constant_path: + │ @ ConstantReadNode (location: (10,7)-(10,8)) + │ └── name: :A + ├── body: + │ @ StatementsNode (location: (11,2)-(15,5)) + │ └── body: (length: 2) + │ ├── @ CallNode (location: (11,2)-(11,16)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :include + │ │ ├── message_loc: (11,2)-(11,9) = "include" + │ │ ├── opening_loc: (11,9)-(11,10) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (11,10)-(11,15)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ CallNode (location: (11,10)-(11,15)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ ConstantReadNode (location: (11,10)-(11,11)) + │ │ │ │ └── name: :B + │ │ │ ├── call_operator_loc: (11,11)-(11,12) = "." + │ │ │ ├── name: :new + │ │ │ ├── message_loc: (11,12)-(11,15) = "new" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: (11,15)-(11,16) = ")" + │ │ └── block: ∅ + │ └── @ DefNode (location: (13,2)-(15,5)) + │ ├── name: :foo + │ ├── name_loc: (13,6)-(13,9) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (14,4)-(14,8)) + │ │ └── body: (length: 1) + │ │ └── @ SymbolNode (location: (14,4)-(14,8)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (14,4)-(14,5) = ":" + │ │ ├── value_loc: (14,5)-(14,8) = "bar" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "bar" + │ ├── locals: [] + │ ├── def_keyword_loc: (13,2)-(13,5) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (15,2)-(15,5) = "end" + ├── end_keyword_loc: (16,0)-(16,3) = "end" + └── name: :A 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..0761b47348 --- /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" + │ ├── binary_operator_loc: (1,2)-(1,4) = "+=" + │ ├── value: + │ │ @ IntegerNode (location: (1,5)-(1,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── binary_operator: :+ + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (2,0)-(2,6)) + │ ├── name_loc: (2,0)-(2,1) = "a" + │ ├── binary_operator_loc: (2,2)-(2,4) = "-=" + │ ├── value: + │ │ @ IntegerNode (location: (2,5)-(2,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── binary_operator: :- + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (3,0)-(3,7)) + │ ├── name_loc: (3,0)-(3,1) = "a" + │ ├── binary_operator_loc: (3,2)-(3,5) = "**=" + │ ├── value: + │ │ @ IntegerNode (location: (3,6)-(3,7)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── binary_operator: :** + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (4,0)-(4,6)) + │ ├── name_loc: (4,0)-(4,1) = "a" + │ ├── binary_operator_loc: (4,2)-(4,4) = "*=" + │ ├── value: + │ │ @ IntegerNode (location: (4,5)-(4,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── binary_operator: :* + │ └── depth: 0 + ├── @ LocalVariableOperatorWriteNode (location: (5,0)-(5,6)) + │ ├── name_loc: (5,0)-(5,1) = "a" + │ ├── binary_operator_loc: (5,2)-(5,4) = "/=" + │ ├── value: + │ │ @ IntegerNode (location: (5,5)-(5,6)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── name: :a + │ ├── binary_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= + │ ├── binary_operator: :+ + │ ├── binary_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= + │ ├── binary_operator: :- + │ ├── binary_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= + │ ├── binary_operator: :** + │ ├── binary_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= + │ ├── binary_operator: :* + │ ├── binary_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= + │ ├── binary_operator: :/ + │ ├── binary_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: ∅ + │ ├── binary_operator: :+ + │ ├── binary_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: ∅ + │ ├── binary_operator: :- + │ ├── binary_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: ∅ + │ ├── binary_operator: :** + │ ├── binary_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: ∅ + │ ├── binary_operator: :* + │ ├── binary_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: ∅ + │ ├── binary_operator: :/ + │ ├── binary_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= + ├── binary_operator: :+ + ├── binary_operator_loc: (24,6)-(24,8) = "+=" + └── value: + @ IntegerNode (location: (24,9)-(24,10)) + ├── flags: decimal + └── value: 1 diff --git a/test/prism/snapshots/unparser/corpus/literal/pattern.txt b/test/prism/snapshots/unparser/corpus/literal/pattern.txt new file mode 100644 index 0000000000..5a0b4bb733 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/pattern.txt @@ -0,0 +1,446 @@ +@ ProgramNode (location: (1,0)-(41,8)) +├── locals: [:a, :x, :y] +└── statements: + @ StatementsNode (location: (1,0)-(41,8)) + └── body: (length: 4) + ├── @ CaseMatchNode (location: (1,0)-(33,3)) + │ ├── predicate: + │ │ @ CallNode (location: (1,5)-(1,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (1,5)-(1,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 15) + │ │ ├── @ InNode (location: (2,0)-(3,6)) + │ │ │ ├── pattern: + │ │ │ │ @ ArrayPatternNode (location: (2,3)-(2,17)) + │ │ │ │ ├── constant: + │ │ │ │ │ @ ConstantReadNode (location: (2,3)-(2,4)) + │ │ │ │ │ └── name: :A + │ │ │ │ ├── requireds: (length: 2) + │ │ │ │ │ ├── @ IntegerNode (location: (2,5)-(2,6)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 1 + │ │ │ │ │ └── @ IntegerNode (location: (2,8)-(2,9)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 2 + │ │ │ │ ├── rest: + │ │ │ │ │ @ SplatNode (location: (2,11)-(2,13)) + │ │ │ │ │ ├── operator_loc: (2,11)-(2,12) = "*" + │ │ │ │ │ └── expression: + │ │ │ │ │ @ LocalVariableTargetNode (location: (2,12)-(2,13)) + │ │ │ │ │ ├── name: :a + │ │ │ │ │ └── depth: 0 + │ │ │ │ ├── posts: (length: 1) + │ │ │ │ │ └── @ IntegerNode (location: (2,15)-(2,16)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 3 + │ │ │ │ ├── opening_loc: (2,4)-(2,5) = "[" + │ │ │ │ └── closing_loc: (2,16)-(2,17) = "]" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (3,2)-(3,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (3,2)-(3,6)) + │ │ │ ├── in_loc: (2,0)-(2,2) = "in" + │ │ │ └── then_loc: (2,18)-(2,22) = "then" + │ │ ├── @ InNode (location: (4,0)-(5,3)) + │ │ │ ├── pattern: + │ │ │ │ @ ArrayPatternNode (location: (4,3)-(4,11)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── requireds: (length: 2) + │ │ │ │ │ ├── @ IntegerNode (location: (4,4)-(4,5)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 1 + │ │ │ │ │ └── @ IntegerNode (location: (4,7)-(4,8)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 2 + │ │ │ │ ├── rest: + │ │ │ │ │ @ ImplicitRestNode (location: (4,8)-(4,9)) + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── opening_loc: (4,3)-(4,4) = "[" + │ │ │ │ └── closing_loc: (4,10)-(4,11) = "]" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (5,2)-(5,3)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (5,2)-(5,3)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :y + │ │ │ │ ├── message_loc: (5,2)-(5,3) = "y" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── in_loc: (4,0)-(4,2) = "in" + │ │ │ └── then_loc: (4,12)-(4,16) = "then" + │ │ ├── @ InNode (location: (6,0)-(7,6)) + │ │ │ ├── pattern: + │ │ │ │ @ HashPatternNode (location: (6,3)-(6,8)) + │ │ │ │ ├── constant: + │ │ │ │ │ @ ConstantReadNode (location: (6,3)-(6,4)) + │ │ │ │ │ └── name: :A + │ │ │ │ ├── elements: (length: 1) + │ │ │ │ │ └── @ AssocNode (location: (6,5)-(6,7)) + │ │ │ │ │ ├── key: + │ │ │ │ │ │ @ SymbolNode (location: (6,5)-(6,7)) + │ │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── value_loc: (6,5)-(6,6) = "x" + │ │ │ │ │ │ ├── closing_loc: (6,6)-(6,7) = ":" + │ │ │ │ │ │ └── unescaped: "x" + │ │ │ │ │ ├── value: + │ │ │ │ │ │ @ ImplicitNode (location: (6,5)-(6,6)) + │ │ │ │ │ │ └── value: + │ │ │ │ │ │ @ LocalVariableTargetNode (location: (6,5)-(6,6)) + │ │ │ │ │ │ ├── name: :x + │ │ │ │ │ │ └── depth: 0 + │ │ │ │ │ └── operator_loc: ∅ + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── opening_loc: (6,4)-(6,5) = "(" + │ │ │ │ └── closing_loc: (6,7)-(6,8) = ")" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (7,2)-(7,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (7,2)-(7,6)) + │ │ │ ├── in_loc: (6,0)-(6,2) = "in" + │ │ │ └── then_loc: (6,9)-(6,13) = "then" + │ │ ├── @ InNode (location: (8,0)-(9,6)) + │ │ │ ├── pattern: + │ │ │ │ @ HashPatternNode (location: (8,3)-(8,8)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ ├── rest: + │ │ │ │ │ @ AssocSplatNode (location: (8,4)-(8,7)) + │ │ │ │ │ ├── value: + │ │ │ │ │ │ @ LocalVariableTargetNode (location: (8,6)-(8,7)) + │ │ │ │ │ │ ├── name: :a + │ │ │ │ │ │ └── depth: 0 + │ │ │ │ │ └── operator_loc: (8,4)-(8,6) = "**" + │ │ │ │ ├── opening_loc: (8,3)-(8,4) = "{" + │ │ │ │ └── closing_loc: (8,7)-(8,8) = "}" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (9,2)-(9,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (9,2)-(9,6)) + │ │ │ ├── in_loc: (8,0)-(8,2) = "in" + │ │ │ └── then_loc: (8,9)-(8,13) = "then" + │ │ ├── @ InNode (location: (10,0)-(11,6)) + │ │ │ ├── pattern: + │ │ │ │ @ IfNode (location: (10,3)-(10,13)) + │ │ │ │ ├── if_keyword_loc: (10,6)-(10,8) = "if" + │ │ │ │ ├── predicate: + │ │ │ │ │ @ TrueNode (location: (10,9)-(10,13)) + │ │ │ │ ├── then_keyword_loc: ∅ + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (10,3)-(10,5)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ HashPatternNode (location: (10,3)-(10,5)) + │ │ │ │ │ ├── constant: ∅ + │ │ │ │ │ ├── elements: (length: 0) + │ │ │ │ │ ├── rest: ∅ + │ │ │ │ │ ├── opening_loc: (10,3)-(10,4) = "{" + │ │ │ │ │ └── closing_loc: (10,4)-(10,5) = "}" + │ │ │ │ ├── consequent: ∅ + │ │ │ │ └── end_keyword_loc: ∅ + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (11,2)-(11,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (11,2)-(11,6)) + │ │ │ ├── in_loc: (10,0)-(10,2) = "in" + │ │ │ └── then_loc: (10,14)-(10,18) = "then" + │ │ ├── @ InNode (location: (12,0)-(13,6)) + │ │ │ ├── pattern: + │ │ │ │ @ ArrayPatternNode (location: (12,3)-(12,12)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── requireds: (length: 2) + │ │ │ │ │ ├── @ LocalVariableTargetNode (location: (12,4)-(12,5)) + │ │ │ │ │ │ ├── name: :x + │ │ │ │ │ │ └── depth: 0 + │ │ │ │ │ └── @ LocalVariableTargetNode (location: (12,7)-(12,8)) + │ │ │ │ │ ├── name: :y + │ │ │ │ │ └── depth: 0 + │ │ │ │ ├── rest: + │ │ │ │ │ @ SplatNode (location: (12,10)-(12,11)) + │ │ │ │ │ ├── operator_loc: (12,10)-(12,11) = "*" + │ │ │ │ │ └── expression: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── opening_loc: (12,3)-(12,4) = "[" + │ │ │ │ └── closing_loc: (12,11)-(12,12) = "]" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (13,2)-(13,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (13,2)-(13,6)) + │ │ │ ├── in_loc: (12,0)-(12,2) = "in" + │ │ │ └── then_loc: (12,13)-(12,17) = "then" + │ │ ├── @ InNode (location: (14,0)-(15,6)) + │ │ │ ├── pattern: + │ │ │ │ @ HashPatternNode (location: (14,3)-(14,16)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── elements: (length: 2) + │ │ │ │ │ ├── @ AssocNode (location: (14,4)-(14,8)) + │ │ │ │ │ │ ├── key: + │ │ │ │ │ │ │ @ SymbolNode (location: (14,4)-(14,6)) + │ │ │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ │ ├── value_loc: (14,4)-(14,5) = "a" + │ │ │ │ │ │ │ ├── closing_loc: (14,5)-(14,6) = ":" + │ │ │ │ │ │ │ └── unescaped: "a" + │ │ │ │ │ │ ├── value: + │ │ │ │ │ │ │ @ IntegerNode (location: (14,7)-(14,8)) + │ │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ │ └── value: 1 + │ │ │ │ │ │ └── operator_loc: ∅ + │ │ │ │ │ └── @ AssocNode (location: (14,10)-(14,15)) + │ │ │ │ │ ├── key: + │ │ │ │ │ │ @ SymbolNode (location: (14,10)-(14,13)) + │ │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── value_loc: (14,10)-(14,12) = "aa" + │ │ │ │ │ │ ├── closing_loc: (14,12)-(14,13) = ":" + │ │ │ │ │ │ └── unescaped: "aa" + │ │ │ │ │ ├── value: + │ │ │ │ │ │ @ IntegerNode (location: (14,14)-(14,15)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 2 + │ │ │ │ │ └── operator_loc: ∅ + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── opening_loc: (14,3)-(14,4) = "{" + │ │ │ │ └── closing_loc: (14,15)-(14,16) = "}" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (15,2)-(15,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (15,2)-(15,6)) + │ │ │ ├── in_loc: (14,0)-(14,2) = "in" + │ │ │ └── then_loc: (14,17)-(14,21) = "then" + │ │ ├── @ InNode (location: (16,0)-(17,6)) + │ │ │ ├── pattern: + │ │ │ │ @ HashPatternNode (location: (16,3)-(16,5)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── opening_loc: (16,3)-(16,4) = "{" + │ │ │ │ └── closing_loc: (16,4)-(16,5) = "}" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (17,2)-(17,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (17,2)-(17,6)) + │ │ │ ├── in_loc: (16,0)-(16,2) = "in" + │ │ │ └── then_loc: (16,6)-(16,10) = "then" + │ │ ├── @ InNode (location: (18,0)-(19,6)) + │ │ │ ├── pattern: + │ │ │ │ @ HashPatternNode (location: (18,3)-(18,10)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── elements: (length: 0) + │ │ │ │ ├── rest: + │ │ │ │ │ @ NoKeywordsParameterNode (location: (18,4)-(18,9)) + │ │ │ │ │ ├── operator_loc: (18,4)-(18,6) = "**" + │ │ │ │ │ └── keyword_loc: (18,6)-(18,9) = "nil" + │ │ │ │ ├── opening_loc: (18,3)-(18,4) = "{" + │ │ │ │ └── closing_loc: (18,9)-(18,10) = "}" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (19,2)-(19,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (19,2)-(19,6)) + │ │ │ ├── in_loc: (18,0)-(18,2) = "in" + │ │ │ └── then_loc: (18,11)-(18,15) = "then" + │ │ ├── @ InNode (location: (20,0)-(21,6)) + │ │ │ ├── pattern: + │ │ │ │ @ HashPatternNode (location: (20,3)-(20,11)) + │ │ │ │ ├── constant: ∅ + │ │ │ │ ├── elements: (length: 1) + │ │ │ │ │ └── @ AssocNode (location: (20,4)-(20,10)) + │ │ │ │ │ ├── key: + │ │ │ │ │ │ @ SymbolNode (location: (20,4)-(20,8)) + │ │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ │ ├── opening_loc: (20,4)-(20,5) = "\"" + │ │ │ │ │ │ ├── value_loc: (20,5)-(20,6) = "a" + │ │ │ │ │ │ ├── closing_loc: (20,6)-(20,8) = "\":" + │ │ │ │ │ │ └── unescaped: "a" + │ │ │ │ │ ├── value: + │ │ │ │ │ │ @ IntegerNode (location: (20,9)-(20,10)) + │ │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ │ └── value: 1 + │ │ │ │ │ └── operator_loc: ∅ + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── opening_loc: (20,3)-(20,4) = "{" + │ │ │ │ └── closing_loc: (20,10)-(20,11) = "}" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (21,2)-(21,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (21,2)-(21,6)) + │ │ │ ├── in_loc: (20,0)-(20,2) = "in" + │ │ │ └── then_loc: (20,12)-(20,16) = "then" + │ │ ├── @ InNode (location: (22,0)-(23,6)) + │ │ │ ├── pattern: + │ │ │ │ @ AlternationPatternNode (location: (22,3)-(22,8)) + │ │ │ │ ├── left: + │ │ │ │ │ @ IntegerNode (location: (22,3)-(22,4)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── right: + │ │ │ │ │ @ IntegerNode (location: (22,7)-(22,8)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 2 + │ │ │ │ └── operator_loc: (22,5)-(22,6) = "|" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (23,2)-(23,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (23,2)-(23,6)) + │ │ │ ├── in_loc: (22,0)-(22,2) = "in" + │ │ │ └── then_loc: (22,9)-(22,13) = "then" + │ │ ├── @ InNode (location: (24,0)-(25,6)) + │ │ │ ├── pattern: + │ │ │ │ @ CapturePatternNode (location: (24,3)-(24,9)) + │ │ │ │ ├── value: + │ │ │ │ │ @ IntegerNode (location: (24,3)-(24,4)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── target: + │ │ │ │ │ @ LocalVariableTargetNode (location: (24,8)-(24,9)) + │ │ │ │ │ ├── name: :a + │ │ │ │ │ └── depth: 0 + │ │ │ │ └── operator_loc: (24,5)-(24,7) = "=>" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (25,2)-(25,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (25,2)-(25,6)) + │ │ │ ├── in_loc: (24,0)-(24,2) = "in" + │ │ │ └── then_loc: (24,10)-(24,14) = "then" + │ │ ├── @ InNode (location: (26,0)-(27,6)) + │ │ │ ├── pattern: + │ │ │ │ @ PinnedVariableNode (location: (26,3)-(26,5)) + │ │ │ │ ├── variable: + │ │ │ │ │ @ LocalVariableReadNode (location: (26,4)-(26,5)) + │ │ │ │ │ ├── name: :x + │ │ │ │ │ └── depth: 0 + │ │ │ │ └── operator_loc: (26,3)-(26,4) = "^" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (27,2)-(27,6)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ TrueNode (location: (27,2)-(27,6)) + │ │ │ ├── in_loc: (26,0)-(26,2) = "in" + │ │ │ └── then_loc: (26,6)-(26,10) = "then" + │ │ ├── @ InNode (location: (28,0)-(28,4)) + │ │ │ ├── pattern: + │ │ │ │ @ IntegerNode (location: (28,3)-(28,4)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── statements: ∅ + │ │ │ ├── in_loc: (28,0)-(28,2) = "in" + │ │ │ └── then_loc: ∅ + │ │ └── @ InNode (location: (29,0)-(30,6)) + │ │ ├── pattern: + │ │ │ @ IntegerNode (location: (29,3)-(29,4)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (30,2)-(30,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ TrueNode (location: (30,2)-(30,6)) + │ │ ├── in_loc: (29,0)-(29,2) = "in" + │ │ └── then_loc: (29,5)-(29,9) = "then" + │ ├── consequent: + │ │ @ ElseNode (location: (31,0)-(33,3)) + │ │ ├── else_keyword_loc: (31,0)-(31,4) = "else" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (32,2)-(32,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ TrueNode (location: (32,2)-(32,6)) + │ │ └── end_keyword_loc: (33,0)-(33,3) = "end" + │ ├── case_keyword_loc: (1,0)-(1,4) = "case" + │ └── end_keyword_loc: (33,0)-(33,3) = "end" + ├── @ CaseMatchNode (location: (34,0)-(36,3)) + │ ├── predicate: + │ │ @ CallNode (location: (34,5)-(34,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (34,5)-(34,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ InNode (location: (35,0)-(35,17)) + │ │ ├── pattern: + │ │ │ @ ArrayPatternNode (location: (35,3)-(35,17)) + │ │ │ ├── constant: + │ │ │ │ @ ConstantReadNode (location: (35,3)-(35,4)) + │ │ │ │ └── name: :A + │ │ │ ├── requireds: (length: 2) + │ │ │ │ ├── @ IntegerNode (location: (35,5)-(35,6)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ └── @ IntegerNode (location: (35,8)-(35,9)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ ├── rest: + │ │ │ │ @ SplatNode (location: (35,11)-(35,13)) + │ │ │ │ ├── operator_loc: (35,11)-(35,12) = "*" + │ │ │ │ └── expression: + │ │ │ │ @ LocalVariableTargetNode (location: (35,12)-(35,13)) + │ │ │ │ ├── name: :a + │ │ │ │ └── depth: 0 + │ │ │ ├── posts: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (35,15)-(35,16)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 3 + │ │ │ ├── opening_loc: (35,4)-(35,5) = "[" + │ │ │ └── closing_loc: (35,16)-(35,17) = "]" + │ │ ├── statements: ∅ + │ │ ├── in_loc: (35,0)-(35,2) = "in" + │ │ └── then_loc: ∅ + │ ├── consequent: ∅ + │ ├── case_keyword_loc: (34,0)-(34,4) = "case" + │ └── end_keyword_loc: (36,0)-(36,3) = "end" + ├── @ CaseMatchNode (location: (37,0)-(40,3)) + │ ├── predicate: + │ │ @ CallNode (location: (37,5)-(37,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (37,5)-(37,8) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── conditions: (length: 1) + │ │ └── @ InNode (location: (38,0)-(38,4)) + │ │ ├── pattern: + │ │ │ @ ConstantReadNode (location: (38,3)-(38,4)) + │ │ │ └── name: :A + │ │ ├── statements: ∅ + │ │ ├── in_loc: (38,0)-(38,2) = "in" + │ │ └── then_loc: ∅ + │ ├── consequent: + │ │ @ ElseNode (location: (39,0)-(40,3)) + │ │ ├── else_keyword_loc: (39,0)-(39,4) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (40,0)-(40,3) = "end" + │ ├── case_keyword_loc: (37,0)-(37,4) = "case" + │ └── end_keyword_loc: (40,0)-(40,3) = "end" + └── @ MatchPredicateNode (location: (41,0)-(41,8)) + ├── value: + │ @ IntegerNode (location: (41,0)-(41,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── pattern: + │ @ ArrayPatternNode (location: (41,5)-(41,8)) + │ ├── constant: ∅ + │ ├── requireds: (length: 1) + │ │ └── @ LocalVariableTargetNode (location: (41,6)-(41,7)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── rest: ∅ + │ ├── posts: (length: 0) + │ ├── opening_loc: (41,5)-(41,6) = "[" + │ └── closing_loc: (41,7)-(41,8) = "]" + └── operator_loc: (41,2)-(41,4) = "in" diff --git a/test/prism/snapshots/unparser/corpus/literal/pragma.txt b/test/prism/snapshots/unparser/corpus/literal/pragma.txt new file mode 100644 index 0000000000..08e386b872 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/pragma.txt @@ -0,0 +1,20 @@ +@ ProgramNode (location: (1,0)-(4,7)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(4,7)) + └── body: (length: 4) + ├── @ SourceEncodingNode (location: (1,0)-(1,12)) + ├── @ SourceFileNode (location: (2,0)-(2,8)) + │ ├── flags: ∅ + │ └── filepath: "unparser/corpus/literal/pragma.txt" + ├── @ SourceLineNode (location: (3,0)-(3,8)) + └── @ CallNode (location: (4,0)-(4,7)) + ├── flags: variable_call, ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :__dir__ + ├── message_loc: (4,0)-(4,7) = "__dir__" + ├── opening_loc: ∅ + ├── arguments: ∅ + ├── closing_loc: ∅ + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/literal/range.txt b/test/prism/snapshots/unparser/corpus/literal/range.txt new file mode 100644 index 0000000000..ab015d04fc --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/range.txt @@ -0,0 +1,55 @@ +@ ProgramNode (location: (1,0)-(4,5)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(4,5)) + └── body: (length: 4) + ├── @ ParenthesesNode (location: (1,0)-(1,5)) + │ ├── body: + │ │ @ StatementsNode (location: (1,1)-(1,4)) + │ │ └── body: (length: 1) + │ │ └── @ RangeNode (location: (1,1)-(1,4)) + │ │ ├── flags: ∅ + │ │ ├── left: + │ │ │ @ IntegerNode (location: (1,1)-(1,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── right: ∅ + │ │ └── operator_loc: (1,2)-(1,4) = ".." + │ ├── opening_loc: (1,0)-(1,1) = "(" + │ └── closing_loc: (1,4)-(1,5) = ")" + ├── @ RangeNode (location: (2,0)-(2,4)) + │ ├── flags: ∅ + │ ├── left: + │ │ @ IntegerNode (location: (2,0)-(2,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── right: + │ │ @ IntegerNode (location: (2,3)-(2,4)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ └── operator_loc: (2,1)-(2,3) = ".." + ├── @ ParenthesesNode (location: (3,0)-(3,6)) + │ ├── body: + │ │ @ StatementsNode (location: (3,1)-(3,5)) + │ │ └── body: (length: 1) + │ │ └── @ RangeNode (location: (3,1)-(3,5)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ IntegerNode (location: (3,1)-(3,2)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ ├── right: ∅ + │ │ └── operator_loc: (3,2)-(3,5) = "..." + │ ├── opening_loc: (3,0)-(3,1) = "(" + │ └── closing_loc: (3,5)-(3,6) = ")" + └── @ RangeNode (location: (4,0)-(4,5)) + ├── flags: exclude_end + ├── left: + │ @ IntegerNode (location: (4,0)-(4,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── right: + │ @ IntegerNode (location: (4,4)-(4,5)) + │ ├── flags: decimal + │ └── value: 2 + └── operator_loc: (4,1)-(4,4) = "..." diff --git a/test/prism/snapshots/unparser/corpus/literal/rescue.txt b/test/prism/snapshots/unparser/corpus/literal/rescue.txt new file mode 100644 index 0000000000..d3c9d62166 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/rescue.txt @@ -0,0 +1,103 @@ +@ ProgramNode (location: (1,0)-(3,27)) +├── locals: [:x] +└── statements: + @ StatementsNode (location: (1,0)-(3,27)) + └── body: (length: 3) + ├── @ RescueModifierNode (location: (1,0)-(1,14)) + │ ├── expression: + │ │ @ CallNode (location: (1,0)-(1,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (1,0)-(1,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── keyword_loc: (1,4)-(1,10) = "rescue" + │ └── rescue_expression: + │ @ CallNode (location: (1,11)-(1,14)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (1,11)-(1,14) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ RescueModifierNode (location: (2,0)-(2,21)) + │ ├── expression: + │ │ @ CallNode (location: (2,0)-(2,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (2,0)-(2,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── keyword_loc: (2,4)-(2,10) = "rescue" + │ └── rescue_expression: + │ @ ReturnNode (location: (2,11)-(2,21)) + │ ├── flags: ∅ + │ ├── keyword_loc: (2,11)-(2,17) = "return" + │ └── arguments: + │ @ ArgumentsNode (location: (2,18)-(2,21)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ CallNode (location: (2,18)-(2,21)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (2,18)-(2,21) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ LocalVariableWriteNode (location: (3,0)-(3,27)) + ├── name: :x + ├── depth: 0 + ├── name_loc: (3,0)-(3,1) = "x" + ├── value: + │ @ ParenthesesNode (location: (3,4)-(3,27)) + │ ├── body: + │ │ @ StatementsNode (location: (3,5)-(3,26)) + │ │ └── body: (length: 1) + │ │ └── @ RescueModifierNode (location: (3,5)-(3,26)) + │ │ ├── expression: + │ │ │ @ CallNode (location: (3,5)-(3,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (3,5)-(3,8) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── keyword_loc: (3,9)-(3,15) = "rescue" + │ │ └── rescue_expression: + │ │ @ ReturnNode (location: (3,16)-(3,26)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (3,16)-(3,22) = "return" + │ │ └── arguments: + │ │ @ ArgumentsNode (location: (3,23)-(3,26)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (3,23)-(3,26)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (3,23)-(3,26) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (3,4)-(3,5) = "(" + │ └── closing_loc: (3,26)-(3,27) = ")" + └── operator_loc: (3,2)-(3,3) = "=" diff --git a/test/prism/snapshots/unparser/corpus/literal/send.txt b/test/prism/snapshots/unparser/corpus/literal/send.txt new file mode 100644 index 0000000000..3fd7f719a1 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/send.txt @@ -0,0 +1,2190 @@ +@ ProgramNode (location: (1,0)-(84,7)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(84,7)) + └── body: (length: 62) + ├── @ ModuleNode (location: (1,0)-(3,3)) + │ ├── locals: [:foo, :a, :_] + │ ├── module_keyword_loc: (1,0)-(1,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (1,7)-(1,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (2,2)-(2,22)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableOrWriteNode (location: (2,2)-(2,22)) + │ │ ├── name_loc: (2,2)-(2,5) = "foo" + │ │ ├── operator_loc: (2,6)-(2,9) = "||=" + │ │ ├── value: + │ │ │ @ ParenthesesNode (location: (2,10)-(2,22)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (2,11)-(2,21)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ MultiWriteNode (location: (2,11)-(2,21)) + │ │ │ │ ├── lefts: (length: 2) + │ │ │ │ │ ├── @ LocalVariableTargetNode (location: (2,12)-(2,13)) + │ │ │ │ │ │ ├── name: :a + │ │ │ │ │ │ └── depth: 0 + │ │ │ │ │ └── @ LocalVariableTargetNode (location: (2,15)-(2,16)) + │ │ │ │ │ ├── name: :_ + │ │ │ │ │ └── depth: 0 + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── rights: (length: 0) + │ │ │ │ ├── lparen_loc: (2,11)-(2,12) = "(" + │ │ │ │ ├── rparen_loc: (2,16)-(2,17) = ")" + │ │ │ │ ├── operator_loc: (2,18)-(2,19) = "=" + │ │ │ │ └── value: + │ │ │ │ @ CallNode (location: (2,20)-(2,21)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (2,20)-(2,21) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── opening_loc: (2,10)-(2,11) = "(" + │ │ │ └── closing_loc: (2,21)-(2,22) = ")" + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── end_keyword_loc: (3,0)-(3,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (5,0)-(8,3)) + │ ├── locals: [:local] + │ ├── module_keyword_loc: (5,0)-(5,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (5,7)-(5,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (6,2)-(7,11)) + │ │ └── body: (length: 2) + │ │ ├── @ LocalVariableWriteNode (location: (6,2)-(6,11)) + │ │ │ ├── name: :local + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (6,2)-(6,7) = "local" + │ │ │ ├── value: + │ │ │ │ @ IntegerNode (location: (6,10)-(6,11)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── operator_loc: (6,8)-(6,9) = "=" + │ │ └── @ CallNode (location: (7,2)-(7,11)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ LocalVariableReadNode (location: (7,2)-(7,7)) + │ │ │ ├── name: :local + │ │ │ └── depth: 0 + │ │ ├── call_operator_loc: (7,7)-(7,8) = "." + │ │ ├── name: :bar + │ │ ├── message_loc: (7,8)-(7,11) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── end_keyword_loc: (8,0)-(8,3) = "end" + │ └── name: :A + ├── @ CallNode (location: (9,0)-(10,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ClassNode (location: (9,0)-(10,3)) + │ │ ├── locals: [] + │ │ ├── class_keyword_loc: (9,0)-(9,5) = "class" + │ │ ├── constant_path: + │ │ │ @ ConstantReadNode (location: (9,6)-(9,7)) + │ │ │ └── name: :A + │ │ ├── inheritance_operator_loc: ∅ + │ │ ├── superclass: ∅ + │ │ ├── body: ∅ + │ │ ├── end_keyword_loc: (10,0)-(10,3) = "end" + │ │ └── name: :A + │ ├── call_operator_loc: (10,3)-(10,4) = "." + │ ├── name: :bar + │ ├── message_loc: (10,4)-(10,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (11,0)-(12,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ModuleNode (location: (11,0)-(12,3)) + │ │ ├── locals: [] + │ │ ├── module_keyword_loc: (11,0)-(11,6) = "module" + │ │ ├── constant_path: + │ │ │ @ ConstantReadNode (location: (11,7)-(11,8)) + │ │ │ └── name: :A + │ │ ├── body: ∅ + │ │ ├── end_keyword_loc: (12,0)-(12,3) = "end" + │ │ └── name: :A + │ ├── call_operator_loc: (12,3)-(12,4) = "." + │ ├── name: :bar + │ ├── message_loc: (12,4)-(12,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (13,0)-(15,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ BeginNode (location: (13,0)-(15,3)) + │ │ ├── begin_keyword_loc: (13,0)-(13,5) = "begin" + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (14,0)-(14,6)) + │ │ │ ├── keyword_loc: (14,0)-(14,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (15,0)-(15,3) = "end" + │ ├── call_operator_loc: (15,3)-(15,4) = "." + │ ├── name: :bar + │ ├── message_loc: (15,4)-(15,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (16,0)-(19,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CaseNode (location: (16,0)-(19,3)) + │ │ ├── predicate: + │ │ │ @ ParenthesesNode (location: (16,5)-(17,10)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (16,6)-(17,9)) + │ │ │ │ └── body: (length: 2) + │ │ │ │ ├── @ DefNode (location: (16,6)-(17,3)) + │ │ │ │ │ ├── name: :foo + │ │ │ │ │ ├── name_loc: (16,10)-(16,13) = "foo" + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── parameters: ∅ + │ │ │ │ │ ├── body: ∅ + │ │ │ │ │ ├── locals: [] + │ │ │ │ │ ├── def_keyword_loc: (16,6)-(16,9) = "def" + │ │ │ │ │ ├── operator_loc: ∅ + │ │ │ │ │ ├── lparen_loc: ∅ + │ │ │ │ │ ├── rparen_loc: ∅ + │ │ │ │ │ ├── equal_loc: ∅ + │ │ │ │ │ └── end_keyword_loc: (17,0)-(17,3) = "end" + │ │ │ │ └── @ SymbolNode (location: (17,5)-(17,9)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (17,5)-(17,6) = ":" + │ │ │ │ ├── value_loc: (17,6)-(17,9) = "bar" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "bar" + │ │ │ ├── opening_loc: (16,5)-(16,6) = "(" + │ │ │ └── closing_loc: (17,9)-(17,10) = ")" + │ │ ├── conditions: (length: 1) + │ │ │ └── @ WhenNode (location: (18,0)-(18,8)) + │ │ │ ├── keyword_loc: (18,0)-(18,4) = "when" + │ │ │ ├── conditions: (length: 1) + │ │ │ │ └── @ CallNode (location: (18,5)-(18,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (18,5)-(18,8) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ └── statements: ∅ + │ │ ├── consequent: ∅ + │ │ ├── case_keyword_loc: (16,0)-(16,4) = "case" + │ │ └── end_keyword_loc: (19,0)-(19,3) = "end" + │ ├── call_operator_loc: (19,3)-(19,4) = "." + │ ├── name: :baz + │ ├── message_loc: (19,4)-(19,7) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (20,0)-(22,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CaseNode (location: (20,0)-(22,3)) + │ │ ├── predicate: + │ │ │ @ CallNode (location: (20,5)-(20,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (20,5)-(20,8) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── conditions: (length: 1) + │ │ │ └── @ WhenNode (location: (21,0)-(21,8)) + │ │ │ ├── keyword_loc: (21,0)-(21,4) = "when" + │ │ │ ├── conditions: (length: 1) + │ │ │ │ └── @ CallNode (location: (21,5)-(21,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (21,5)-(21,8) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── then_keyword_loc: ∅ + │ │ │ └── statements: ∅ + │ │ ├── consequent: ∅ + │ │ ├── case_keyword_loc: (20,0)-(20,4) = "case" + │ │ └── end_keyword_loc: (22,0)-(22,3) = "end" + │ ├── call_operator_loc: (22,3)-(22,4) = "." + │ ├── name: :baz + │ ├── message_loc: (22,4)-(22,7) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (23,0)-(24,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ SingletonClassNode (location: (23,0)-(24,3)) + │ │ ├── locals: [] + │ │ ├── class_keyword_loc: (23,0)-(23,5) = "class" + │ │ ├── operator_loc: (23,6)-(23,8) = "<<" + │ │ ├── expression: + │ │ │ @ SelfNode (location: (23,9)-(23,13)) + │ │ ├── body: ∅ + │ │ └── end_keyword_loc: (24,0)-(24,3) = "end" + │ ├── call_operator_loc: (24,3)-(24,4) = "." + │ ├── name: :bar + │ ├── message_loc: (24,4)-(24,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (25,0)-(26,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ DefNode (location: (25,0)-(26,3)) + │ │ ├── name: :foo + │ │ ├── name_loc: (25,9)-(25,12) = "foo" + │ │ ├── receiver: + │ │ │ @ SelfNode (location: (25,4)-(25,8)) + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── locals: [] + │ │ ├── def_keyword_loc: (25,0)-(25,3) = "def" + │ │ ├── operator_loc: (25,8)-(25,9) = "." + │ │ ├── lparen_loc: ∅ + │ │ ├── rparen_loc: ∅ + │ │ ├── equal_loc: ∅ + │ │ └── end_keyword_loc: (26,0)-(26,3) = "end" + │ ├── call_operator_loc: (26,3)-(26,4) = "." + │ ├── name: :bar + │ ├── message_loc: (26,4)-(26,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (27,0)-(28,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ DefNode (location: (27,0)-(28,3)) + │ │ ├── name: :foo + │ │ ├── name_loc: (27,4)-(27,7) = "foo" + │ │ ├── receiver: ∅ + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── locals: [] + │ │ ├── def_keyword_loc: (27,0)-(27,3) = "def" + │ │ ├── operator_loc: ∅ + │ │ ├── lparen_loc: ∅ + │ │ ├── rparen_loc: ∅ + │ │ ├── equal_loc: ∅ + │ │ └── end_keyword_loc: (28,0)-(28,3) = "end" + │ ├── call_operator_loc: (28,3)-(28,4) = "." + │ ├── name: :bar + │ ├── message_loc: (28,4)-(28,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (29,0)-(30,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ UntilNode (location: (29,0)-(30,3)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (29,0)-(29,5) = "until" + │ │ ├── closing_loc: (30,0)-(30,3) = "end" + │ │ ├── predicate: + │ │ │ @ CallNode (location: (29,6)-(29,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (29,6)-(29,9) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── statements: ∅ + │ ├── call_operator_loc: (30,3)-(30,4) = "." + │ ├── name: :bar + │ ├── message_loc: (30,4)-(30,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (31,0)-(32,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ WhileNode (location: (31,0)-(32,3)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (31,0)-(31,5) = "while" + │ │ ├── closing_loc: (32,0)-(32,3) = "end" + │ │ ├── predicate: + │ │ │ @ CallNode (location: (31,6)-(31,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (31,6)-(31,9) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── statements: ∅ + │ ├── call_operator_loc: (32,3)-(32,4) = "." + │ ├── name: :bar + │ ├── message_loc: (32,4)-(32,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (33,0)-(34,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (33,0)-(34,1)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :loop + │ │ ├── message_loc: (33,0)-(33,4) = "loop" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (33,5)-(34,1)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (33,5)-(33,6) = "{" + │ │ └── closing_loc: (34,0)-(34,1) = "}" + │ ├── call_operator_loc: (34,1)-(34,2) = "." + │ ├── name: :bar + │ ├── message_loc: (34,2)-(34,5) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (35,0)-(36,7)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ IfNode (location: (35,0)-(36,3)) + │ │ ├── if_keyword_loc: (35,0)-(35,2) = "if" + │ │ ├── predicate: + │ │ │ @ CallNode (location: (35,3)-(35,6)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (35,3)-(35,6) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── then_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── consequent: ∅ + │ │ └── end_keyword_loc: (36,0)-(36,3) = "end" + │ ├── call_operator_loc: (36,3)-(36,4) = "." + │ ├── name: :baz + │ ├── message_loc: (36,4)-(36,7) = "baz" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (37,0)-(37,19)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (37,0)-(37,15)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (37,1)-(37,14)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (37,1)-(37,14)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ RegularExpressionNode (location: (37,1)-(37,6)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (37,1)-(37,2) = "/" + │ │ │ │ ├── content_loc: (37,2)-(37,5) = "bar" + │ │ │ │ ├── closing_loc: (37,5)-(37,6) = "/" + │ │ │ │ └── unescaped: "bar" + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :=~ + │ │ │ ├── message_loc: (37,7)-(37,9) = "=~" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (37,10)-(37,14)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ SymbolNode (location: (37,10)-(37,14)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (37,10)-(37,11) = ":" + │ │ │ │ ├── value_loc: (37,11)-(37,14) = "foo" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "foo" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (37,0)-(37,1) = "(" + │ │ └── closing_loc: (37,14)-(37,15) = ")" + │ ├── call_operator_loc: (37,15)-(37,16) = "." + │ ├── name: :foo + │ ├── message_loc: (37,16)-(37,19) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (38,0)-(38,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (38,0)-(38,6)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (38,1)-(38,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ RangeNode (location: (38,1)-(38,5)) + │ │ │ ├── flags: ∅ + │ │ │ ├── left: + │ │ │ │ @ IntegerNode (location: (38,1)-(38,2)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── right: + │ │ │ │ @ IntegerNode (location: (38,4)-(38,5)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 2 + │ │ │ └── operator_loc: (38,2)-(38,4) = ".." + │ │ ├── opening_loc: (38,0)-(38,1) = "(" + │ │ └── closing_loc: (38,5)-(38,6) = ")" + │ ├── call_operator_loc: (38,6)-(38,7) = "." + │ ├── name: :max + │ ├── message_loc: (38,7)-(38,10) = "max" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (39,0)-(39,18)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (39,0)-(39,14)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (39,1)-(39,13)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (39,1)-(39,13)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (39,1)-(39,4)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (39,1)-(39,4) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :=~ + │ │ │ ├── message_loc: (39,5)-(39,7) = "=~" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (39,8)-(39,13)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ RegularExpressionNode (location: (39,8)-(39,13)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: (39,8)-(39,9) = "/" + │ │ │ │ ├── content_loc: (39,9)-(39,12) = "bar" + │ │ │ │ ├── closing_loc: (39,12)-(39,13) = "/" + │ │ │ │ └── unescaped: "bar" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (39,0)-(39,1) = "(" + │ │ └── closing_loc: (39,13)-(39,14) = ")" + │ ├── call_operator_loc: (39,14)-(39,15) = "." + │ ├── name: :foo + │ ├── message_loc: (39,15)-(39,18) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (40,0)-(40,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ RegularExpressionNode (location: (40,0)-(40,5)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (40,0)-(40,1) = "/" + │ │ ├── content_loc: (40,1)-(40,4) = "bar" + │ │ ├── closing_loc: (40,4)-(40,5) = "/" + │ │ └── unescaped: "bar" + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (40,6)-(40,8) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (40,9)-(40,13)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (40,9)-(40,13)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (40,9)-(40,10) = ":" + │ │ ├── value_loc: (40,10)-(40,13) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (41,0)-(41,12)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ RegularExpressionNode (location: (41,0)-(41,5)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (41,0)-(41,1) = "/" + │ │ ├── content_loc: (41,1)-(41,4) = "bar" + │ │ ├── closing_loc: (41,4)-(41,5) = "/" + │ │ └── unescaped: "bar" + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (41,6)-(41,8) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (41,9)-(41,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (41,9)-(41,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (41,9)-(41,12) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ RangeNode (location: (42,0)-(42,8)) + │ ├── flags: ∅ + │ ├── left: + │ │ @ IntegerNode (location: (42,0)-(42,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── right: + │ │ @ CallNode (location: (42,3)-(42,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ IntegerNode (location: (42,3)-(42,4)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 2 + │ │ ├── call_operator_loc: (42,4)-(42,5) = "." + │ │ ├── name: :max + │ │ ├── message_loc: (42,5)-(42,8) = "max" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (42,1)-(42,3) = ".." + ├── @ CallNode (location: (43,0)-(43,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ConstantReadNode (location: (43,0)-(43,1)) + │ │ └── name: :A + │ ├── call_operator_loc: (43,1)-(43,2) = "." + │ ├── name: :foo + │ ├── message_loc: (43,2)-(43,5) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (44,0)-(44,5)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :FOO + │ ├── message_loc: (44,0)-(44,3) = "FOO" + │ ├── opening_loc: (44,3)-(44,4) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (44,4)-(44,5) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (45,0)-(45,4)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (45,0)-(45,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (45,0)-(45,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (45,1)-(45,3) = "&." + │ ├── name: :b + │ ├── message_loc: (45,3)-(45,4) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (46,0)-(46,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (46,0)-(46,1)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (46,0)-(46,1) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (46,1)-(46,2) = "." + │ ├── name: :foo + │ ├── message_loc: (46,2)-(46,5) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (47,0)-(47,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (47,0)-(47,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (48,0)-(48,18)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (48,0)-(48,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (48,0)-(48,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :<< + │ ├── message_loc: (48,4)-(48,6) = "<<" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (48,7)-(48,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ParenthesesNode (location: (48,7)-(48,18)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (48,8)-(48,17)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (48,8)-(48,17)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (48,8)-(48,11)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (48,8)-(48,11) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :* + │ │ │ ├── message_loc: (48,12)-(48,13) = "*" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (48,14)-(48,17)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (48,14)-(48,17)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (48,14)-(48,17) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (48,7)-(48,8) = "(" + │ │ └── closing_loc: (48,17)-(48,18) = ")" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (49,0)-(49,12)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (49,0)-(49,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (49,0)-(49,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :=~ + │ ├── message_loc: (49,4)-(49,6) = "=~" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (49,7)-(49,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ RegularExpressionNode (location: (49,7)-(49,12)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (49,7)-(49,8) = "/" + │ │ ├── content_loc: (49,8)-(49,11) = "bar" + │ │ ├── closing_loc: (49,11)-(49,12) = "/" + │ │ └── unescaped: "bar" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (50,0)-(50,17)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (50,0)-(50,3) = "foo" + │ ├── opening_loc: (50,3)-(50,4) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (50,17)-(50,18) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (50,4)-(50,17)) + │ ├── expression: + │ │ @ ParenthesesNode (location: (50,5)-(50,17)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (50,6)-(50,16)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ OrNode (location: (50,6)-(50,16)) + │ │ │ ├── left: + │ │ │ │ @ CallNode (location: (50,6)-(50,9)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (50,6)-(50,9) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── right: + │ │ │ │ @ CallNode (location: (50,13)-(50,16)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (50,13)-(50,16) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (50,10)-(50,12) = "||" + │ │ ├── opening_loc: (50,5)-(50,6) = "(" + │ │ └── closing_loc: (50,16)-(50,17) = ")" + │ └── operator_loc: (50,4)-(50,5) = "&" + ├── @ CallNode (location: (51,0)-(51,10)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (51,0)-(51,3) = "foo" + │ ├── opening_loc: (51,3)-(51,4) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (51,10)-(51,11) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (51,4)-(51,10)) + │ ├── expression: + │ │ @ CallNode (location: (51,5)-(51,10)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :block + │ │ ├── message_loc: (51,5)-(51,10) = "block" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (51,4)-(51,5) = "&" + ├── @ CallNode (location: (52,0)-(52,17)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (52,0)-(52,3) = "foo" + │ ├── opening_loc: (52,3)-(52,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (52,4)-(52,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (52,4)-(52,9)) + │ │ ├── operator_loc: (52,4)-(52,5) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (52,5)-(52,9)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :args + │ │ ├── message_loc: (52,5)-(52,9) = "args" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (52,17)-(52,18) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (52,11)-(52,17)) + │ ├── expression: + │ │ @ CallNode (location: (52,12)-(52,17)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :block + │ │ ├── message_loc: (52,12)-(52,17) = "block" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (52,11)-(52,12) = "&" + ├── @ CallNode (location: (53,0)-(53,15)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (53,0)-(53,3) = "foo" + │ ├── opening_loc: (53,3)-(53,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (53,4)-(53,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (53,4)-(53,14)) + │ │ ├── operator_loc: (53,4)-(53,5) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (53,5)-(53,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :arguments + │ │ ├── message_loc: (53,5)-(53,14) = "arguments" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (53,14)-(53,15) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (54,0)-(54,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (54,0)-(54,3) = "foo" + │ ├── opening_loc: (54,3)-(54,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (54,4)-(54,8)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ IntegerNode (location: (54,4)-(54,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (54,7)-(54,8)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── closing_loc: (54,8)-(54,9) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (55,0)-(55,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (55,0)-(55,3) = "foo" + │ ├── opening_loc: (55,3)-(55,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (55,4)-(55,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (55,4)-(55,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (55,4)-(55,7) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (55,7)-(55,8) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (56,0)-(56,15)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (56,0)-(56,3) = "foo" + │ ├── opening_loc: (56,3)-(56,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (56,4)-(56,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (56,4)-(56,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (56,4)-(56,7) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ SplatNode (location: (56,9)-(56,14)) + │ │ ├── operator_loc: (56,9)-(56,10) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (56,10)-(56,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :args + │ │ ├── message_loc: (56,10)-(56,14) = "args" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (56,14)-(56,15) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (57,0)-(57,17)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (57,0)-(57,3) = "foo" + │ ├── opening_loc: (57,3)-(57,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (57,4)-(57,16)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (57,4)-(57,16)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (57,4)-(57,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (57,4)-(57,7) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :=~ + │ │ ├── message_loc: (57,8)-(57,10) = "=~" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (57,11)-(57,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ RegularExpressionNode (location: (57,11)-(57,16)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: (57,11)-(57,12) = "/" + │ │ │ ├── content_loc: (57,12)-(57,15) = "bar" + │ │ │ ├── closing_loc: (57,15)-(57,16) = "/" + │ │ │ └── unescaped: "bar" + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (57,16)-(57,17) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (58,0)-(58,13)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (58,0)-(58,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (58,0)-(58,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (58,3)-(58,4) = "." + │ ├── name: :bar + │ ├── message_loc: (58,4)-(58,7) = "bar" + │ ├── opening_loc: (58,7)-(58,8) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (58,12)-(58,13) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (58,8)-(58,12)) + │ ├── expression: + │ │ @ CallNode (location: (58,9)-(58,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (58,9)-(58,12) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (58,8)-(58,9) = "&" + ├── @ CallNode (location: (59,0)-(59,26)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (59,0)-(59,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (59,0)-(59,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (59,3)-(59,4) = "." + │ ├── name: :bar + │ ├── message_loc: (59,4)-(59,7) = "bar" + │ ├── opening_loc: (59,7)-(59,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (59,8)-(59,25)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 3) + │ │ ├── @ SplatNode (location: (59,8)-(59,13)) + │ │ │ ├── operator_loc: (59,8)-(59,9) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (59,9)-(59,13)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :arga + │ │ │ ├── message_loc: (59,9)-(59,13) = "arga" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── @ CallNode (location: (59,15)-(59,18)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (59,15)-(59,18) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ SplatNode (location: (59,20)-(59,25)) + │ │ ├── operator_loc: (59,20)-(59,21) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (59,21)-(59,25)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :argb + │ │ ├── message_loc: (59,21)-(59,25) = "argb" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (59,25)-(59,26) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (60,0)-(60,14)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (60,0)-(60,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (60,0)-(60,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (60,3)-(60,4) = "." + │ ├── name: :bar + │ ├── message_loc: (60,4)-(60,7) = "bar" + │ ├── opening_loc: (60,7)-(60,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (60,8)-(60,13)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (60,8)-(60,13)) + │ │ ├── operator_loc: (60,8)-(60,9) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (60,9)-(60,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :args + │ │ ├── message_loc: (60,9)-(60,13) = "args" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (60,13)-(60,14) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (61,0)-(61,19)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (61,0)-(61,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (61,0)-(61,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (61,3)-(61,4) = "." + │ ├── name: :bar + │ ├── message_loc: (61,4)-(61,7) = "bar" + │ ├── opening_loc: (61,7)-(61,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (61,8)-(61,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ SplatNode (location: (61,8)-(61,13)) + │ │ │ ├── operator_loc: (61,8)-(61,9) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (61,9)-(61,13)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :args + │ │ │ ├── message_loc: (61,9)-(61,13) = "args" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (61,15)-(61,18)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (61,15)-(61,18) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (61,18)-(61,19) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (62,0)-(62,19)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (62,0)-(62,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (62,0)-(62,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (62,3)-(62,4) = "." + │ ├── name: :bar + │ ├── message_loc: (62,4)-(62,7) = "bar" + │ ├── opening_loc: (62,7)-(62,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (62,8)-(62,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (62,8)-(62,12)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (62,8)-(62,9) = ":" + │ │ ├── value_loc: (62,9)-(62,12) = "baz" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "baz" + │ ├── closing_loc: (62,18)-(62,19) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (62,14)-(62,18)) + │ ├── expression: + │ │ @ CallNode (location: (62,15)-(62,18)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (62,15)-(62,18) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (62,14)-(62,15) = "&" + ├── @ CallNode (location: (63,0)-(63,17)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (63,0)-(63,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (63,0)-(63,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (63,3)-(63,4) = "." + │ ├── name: :bar + │ ├── message_loc: (63,4)-(63,7) = "bar" + │ ├── opening_loc: (63,7)-(63,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (63,8)-(63,16)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (63,8)-(63,16)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (63,8)-(63,16)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (63,8)-(63,12)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (63,8)-(63,11) = "baz" + │ │ │ ├── closing_loc: (63,11)-(63,12) = ":" + │ │ │ └── unescaped: "baz" + │ │ ├── value: + │ │ │ @ CallNode (location: (63,13)-(63,16)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :boz + │ │ │ ├── message_loc: (63,13)-(63,16) = "boz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: ∅ + │ ├── closing_loc: (63,16)-(63,17) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (64,0)-(64,26)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (64,0)-(64,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (64,0)-(64,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (64,3)-(64,4) = "." + │ ├── name: :bar + │ ├── message_loc: (64,4)-(64,7) = "bar" + │ ├── opening_loc: (64,7)-(64,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (64,8)-(64,25)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (64,8)-(64,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (64,8)-(64,11) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ KeywordHashNode (location: (64,13)-(64,25)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (64,13)-(64,25)) + │ │ ├── key: + │ │ │ @ StringNode (location: (64,13)-(64,18)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (64,13)-(64,14) = "\"" + │ │ │ ├── content_loc: (64,14)-(64,17) = "baz" + │ │ │ ├── closing_loc: (64,17)-(64,18) = "\"" + │ │ │ └── unescaped: "baz" + │ │ ├── value: + │ │ │ @ CallNode (location: (64,22)-(64,25)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :boz + │ │ │ ├── message_loc: (64,22)-(64,25) = "boz" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (64,19)-(64,21) = "=>" + │ ├── closing_loc: (64,25)-(64,26) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (65,0)-(65,19)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (65,0)-(65,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (65,0)-(65,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (65,3)-(65,4) = "." + │ ├── name: :bar + │ ├── message_loc: (65,4)-(65,7) = "bar" + │ ├── opening_loc: (65,7)-(65,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (65,8)-(65,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (65,8)-(65,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (65,8)-(65,11) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ SplatNode (location: (65,13)-(65,18)) + │ │ ├── operator_loc: (65,13)-(65,14) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (65,14)-(65,18)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :args + │ │ ├── message_loc: (65,14)-(65,18) = "args" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (65,18)-(65,19) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (66,0)-(66,27)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (66,0)-(66,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (66,0)-(66,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (66,3)-(66,4) = "." + │ ├── name: :bar + │ ├── message_loc: (66,4)-(66,7) = "bar" + │ ├── opening_loc: (66,7)-(66,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (66,8)-(66,18)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (66,8)-(66,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (66,8)-(66,11) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ SplatNode (location: (66,13)-(66,18)) + │ │ ├── operator_loc: (66,13)-(66,14) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (66,14)-(66,18)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :args + │ │ ├── message_loc: (66,14)-(66,18) = "args" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (66,26)-(66,27) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (66,20)-(66,26)) + │ ├── expression: + │ │ @ CallNode (location: (66,21)-(66,26)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :block + │ │ ├── message_loc: (66,21)-(66,26) = "block" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (66,20)-(66,21) = "&" + ├── @ CallNode (location: (67,0)-(67,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (67,0)-(67,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (67,0)-(67,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (67,3)-(67,4) = "." + │ ├── name: :bar + │ ├── message_loc: (67,4)-(67,7) = "bar" + │ ├── opening_loc: (67,7)-(67,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (67,8)-(67,15)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (67,8)-(67,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (67,8)-(67,11) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ HashNode (location: (67,13)-(67,15)) + │ │ ├── opening_loc: (67,13)-(67,14) = "{" + │ │ ├── elements: (length: 0) + │ │ └── closing_loc: (67,14)-(67,15) = "}" + │ ├── closing_loc: (67,15)-(67,16) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (68,0)-(68,26)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (68,0)-(68,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (68,0)-(68,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (68,3)-(68,4) = "." + │ ├── name: :bar + │ ├── message_loc: (68,4)-(68,7) = "bar" + │ ├── opening_loc: (68,7)-(68,8) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (68,8)-(68,25)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ HashNode (location: (68,8)-(68,20)) + │ │ │ ├── opening_loc: (68,8)-(68,9) = "{" + │ │ │ ├── elements: (length: 1) + │ │ │ │ └── @ AssocNode (location: (68,10)-(68,18)) + │ │ │ │ ├── key: + │ │ │ │ │ @ SymbolNode (location: (68,10)-(68,14)) + │ │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── value_loc: (68,10)-(68,13) = "foo" + │ │ │ │ │ ├── closing_loc: (68,13)-(68,14) = ":" + │ │ │ │ │ └── unescaped: "foo" + │ │ │ │ ├── value: + │ │ │ │ │ @ CallNode (location: (68,15)-(68,18)) + │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ ├── name: :boz + │ │ │ │ │ ├── message_loc: (68,15)-(68,18) = "boz" + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── block: ∅ + │ │ │ │ └── operator_loc: ∅ + │ │ │ └── closing_loc: (68,19)-(68,20) = "}" + │ │ └── @ CallNode (location: (68,22)-(68,25)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :boz + │ │ ├── message_loc: (68,22)-(68,25) = "boz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (68,25)-(68,26) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (69,0)-(69,12)) + │ ├── flags: attribute_write + │ ├── receiver: + │ │ @ CallNode (location: (69,0)-(69,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (69,0)-(69,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (69,3)-(69,4) = "." + │ ├── name: :bar= + │ ├── message_loc: (69,4)-(69,7) = "bar" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (69,8)-(69,12)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (69,8)-(69,12)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (69,8)-(69,9) = ":" + │ │ ├── value_loc: (69,9)-(69,12) = "baz" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "baz" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (70,0)-(70,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (70,0)-(70,3) = "foo" + │ ├── opening_loc: (70,3)-(70,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (70,4)-(70,8)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (70,4)-(70,8)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (70,4)-(70,8)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (70,4)-(70,6)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (70,4)-(70,5) = "a" + │ │ │ ├── closing_loc: (70,5)-(70,6) = ":" + │ │ │ └── unescaped: "a" + │ │ ├── value: + │ │ │ @ CallNode (location: (70,7)-(70,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (70,7)-(70,8) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: ∅ + │ ├── closing_loc: (70,8)-(70,9) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (71,0)-(71,11)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (71,0)-(71,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (71,0)-(71,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (71,3)-(71,4) = "." + │ ├── name: :& + │ ├── message_loc: (71,4)-(71,5) = "&" + │ ├── opening_loc: (71,5)-(71,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (71,6)-(71,10)) + │ │ ├── flags: contains_keywords + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (71,6)-(71,10)) + │ │ ├── flags: symbol_keys + │ │ └── elements: (length: 1) + │ │ └── @ AssocNode (location: (71,6)-(71,10)) + │ │ ├── key: + │ │ │ @ SymbolNode (location: (71,6)-(71,8)) + │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── value_loc: (71,6)-(71,7) = "a" + │ │ │ ├── closing_loc: (71,7)-(71,8) = ":" + │ │ │ └── unescaped: "a" + │ │ ├── value: + │ │ │ @ CallNode (location: (71,9)-(71,10)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (71,9)-(71,10) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: ∅ + │ ├── closing_loc: (71,10)-(71,11) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (72,0)-(72,10)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (72,0)-(72,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (72,0)-(72,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (72,3)-(72,4) = "." + │ ├── name: :& + │ ├── message_loc: (72,4)-(72,5) = "&" + │ ├── opening_loc: (72,5)-(72,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (72,6)-(72,9)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (72,6)-(72,9)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (72,6)-(72,9)) + │ │ ├── value: + │ │ │ @ CallNode (location: (72,8)-(72,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (72,8)-(72,9) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (72,6)-(72,8) = "**" + │ ├── closing_loc: (72,9)-(72,10) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (73,0)-(73,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (73,0)-(73,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (73,0)-(73,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (73,3)-(73,9) = "[*baz]" + │ ├── opening_loc: (73,3)-(73,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (73,4)-(73,8)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SplatNode (location: (73,4)-(73,8)) + │ │ ├── operator_loc: (73,4)-(73,5) = "*" + │ │ └── expression: + │ │ @ CallNode (location: (73,5)-(73,8)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (73,5)-(73,8) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (73,8)-(73,9) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (74,0)-(74,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (74,0)-(74,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (74,0)-(74,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (74,3)-(74,9) = "[1, 2]" + │ ├── opening_loc: (74,3)-(74,4) = "[" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (74,4)-(74,8)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ IntegerNode (location: (74,4)-(74,5)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 1 + │ │ └── @ IntegerNode (location: (74,7)-(74,8)) + │ │ ├── flags: decimal + │ │ └── value: 2 + │ ├── closing_loc: (74,8)-(74,9) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (75,0)-(75,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (75,0)-(75,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (75,0)-(75,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :[] + │ ├── message_loc: (75,3)-(75,5) = "[]" + │ ├── opening_loc: (75,3)-(75,4) = "[" + │ ├── arguments: ∅ + │ ├── closing_loc: (75,4)-(75,5) = "]" + │ └── block: ∅ + ├── @ CallNode (location: (76,0)-(76,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: + │ │ @ SelfNode (location: (76,0)-(76,4)) + │ ├── call_operator_loc: (76,4)-(76,5) = "." + │ ├── name: :foo + │ ├── message_loc: (76,5)-(76,8) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (77,0)-(77,13)) + │ ├── flags: attribute_write, ignore_visibility + │ ├── receiver: + │ │ @ SelfNode (location: (77,0)-(77,4)) + │ ├── call_operator_loc: (77,4)-(77,5) = "." + │ ├── name: :foo= + │ ├── message_loc: (77,5)-(77,8) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (77,9)-(77,13)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ SymbolNode (location: (77,9)-(77,13)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (77,9)-(77,10) = ":" + │ │ ├── value_loc: (77,10)-(77,13) = "bar" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "bar" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (78,0)-(78,17)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (78,0)-(78,7)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (78,1)-(78,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (78,1)-(78,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (78,1)-(78,2)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (78,1)-(78,2) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :+ + │ │ │ ├── message_loc: (78,3)-(78,4) = "+" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (78,5)-(78,6)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (78,5)-(78,6)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (78,5)-(78,6) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (78,0)-(78,1) = "(" + │ │ └── closing_loc: (78,6)-(78,7) = ")" + │ ├── call_operator_loc: ∅ + │ ├── name: :/ + │ ├── message_loc: (78,8)-(78,9) = "/" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (78,10)-(78,17)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ ParenthesesNode (location: (78,10)-(78,17)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (78,11)-(78,16)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (78,11)-(78,16)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (78,11)-(78,12)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :c + │ │ │ │ ├── message_loc: (78,11)-(78,12) = "c" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :- + │ │ │ ├── message_loc: (78,13)-(78,14) = "-" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (78,15)-(78,16)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (78,15)-(78,16)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :d + │ │ │ │ ├── message_loc: (78,15)-(78,16) = "d" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (78,10)-(78,11) = "(" + │ │ └── closing_loc: (78,16)-(78,17) = ")" + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (79,0)-(79,19)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (79,0)-(79,7)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (79,1)-(79,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (79,1)-(79,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (79,1)-(79,2)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (79,1)-(79,2) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :+ + │ │ │ ├── message_loc: (79,3)-(79,4) = "+" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (79,5)-(79,6)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (79,5)-(79,6)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (79,5)-(79,6) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (79,0)-(79,1) = "(" + │ │ └── closing_loc: (79,6)-(79,7) = ")" + │ ├── call_operator_loc: ∅ + │ ├── name: :/ + │ ├── message_loc: (79,8)-(79,9) = "/" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (79,10)-(79,19)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (79,10)-(79,19)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (79,10)-(79,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (79,10)-(79,11) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (79,11)-(79,12) = "." + │ │ ├── name: :- + │ │ ├── message_loc: (79,12)-(79,13) = "-" + │ │ ├── opening_loc: (79,13)-(79,14) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (79,14)-(79,18)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ CallNode (location: (79,14)-(79,15)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :e + │ │ │ │ ├── message_loc: (79,14)-(79,15) = "e" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── @ CallNode (location: (79,17)-(79,18)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :f + │ │ │ ├── message_loc: (79,17)-(79,18) = "f" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: (79,18)-(79,19) = ")" + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (80,0)-(80,17)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (80,0)-(80,7)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (80,1)-(80,6)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (80,1)-(80,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (80,1)-(80,2)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (80,1)-(80,2) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :+ + │ │ │ ├── message_loc: (80,3)-(80,4) = "+" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (80,5)-(80,6)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (80,5)-(80,6)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (80,5)-(80,6) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (80,0)-(80,1) = "(" + │ │ └── closing_loc: (80,6)-(80,7) = ")" + │ ├── call_operator_loc: ∅ + │ ├── name: :/ + │ ├── message_loc: (80,8)-(80,9) = "/" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (80,10)-(80,17)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (80,10)-(80,17)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (80,10)-(80,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (80,10)-(80,11) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (80,11)-(80,12) = "." + │ │ ├── name: :- + │ │ ├── message_loc: (80,12)-(80,13) = "-" + │ │ ├── opening_loc: (80,13)-(80,14) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (80,14)-(80,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ SplatNode (location: (80,14)-(80,16)) + │ │ │ ├── operator_loc: (80,14)-(80,15) = "*" + │ │ │ └── expression: + │ │ │ @ CallNode (location: (80,15)-(80,16)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :f + │ │ │ ├── message_loc: (80,15)-(80,16) = "f" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── closing_loc: (80,16)-(80,17) = ")" + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (81,0)-(81,8)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :x + │ ├── message_loc: (81,0)-(81,1) = "x" + │ ├── opening_loc: (81,1)-(81,2) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (81,2)-(81,7)) + │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ └── arguments: (length: 1) + │ │ └── @ KeywordHashNode (location: (81,2)-(81,7)) + │ │ ├── flags: ∅ + │ │ └── elements: (length: 1) + │ │ └── @ AssocSplatNode (location: (81,2)-(81,7)) + │ │ ├── value: + │ │ │ @ CallNode (location: (81,4)-(81,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (81,4)-(81,7) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (81,2)-(81,4) = "**" + │ ├── closing_loc: (81,7)-(81,8) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (82,0)-(82,6)) + │ ├── flags: safe_navigation + │ ├── receiver: + │ │ @ CallNode (location: (82,0)-(82,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (82,0)-(82,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (82,3)-(82,5) = "&." + │ ├── name: :! + │ ├── message_loc: (82,5)-(82,6) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (83,0)-(83,8)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (83,0)-(83,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (83,0)-(83,3) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (83,3)-(83,4) = "." + │ ├── name: :~ + │ ├── message_loc: (83,4)-(83,5) = "~" + │ ├── opening_loc: (83,5)-(83,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (83,6)-(83,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (83,6)-(83,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (83,6)-(83,7) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (83,7)-(83,8) = ")" + │ └── block: ∅ + └── @ CallNode (location: (84,0)-(84,7)) + ├── flags: safe_navigation + ├── receiver: + │ @ CallNode (location: (84,0)-(84,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (84,0)-(84,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: (84,1)-(84,3) = "&." + ├── name: :+ + ├── message_loc: (84,3)-(84,4) = "+" + ├── opening_loc: (84,4)-(84,5) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (84,5)-(84,6)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ CallNode (location: (84,5)-(84,6)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :b + │ ├── message_loc: (84,5)-(84,6) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── closing_loc: (84,6)-(84,7) = ")" + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/literal/since/27.txt b/test/prism/snapshots/unparser/corpus/literal/since/27.txt new file mode 100644 index 0000000000..60edc18604 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/since/27.txt @@ -0,0 +1,49 @@ +@ ProgramNode (location: (1,0)-(4,5)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(4,5)) + └── body: (length: 2) + ├── @ LambdaNode (location: (1,0)-(3,1)) + │ ├── locals: [:_1, :_2] + │ ├── operator_loc: (1,0)-(1,2) = "->" + │ ├── opening_loc: (1,3)-(1,4) = "{" + │ ├── closing_loc: (3,0)-(3,1) = "}" + │ ├── parameters: + │ │ @ NumberedParametersNode (location: (1,0)-(3,1)) + │ │ └── maximum: 2 + │ └── body: + │ @ StatementsNode (location: (2,2)-(2,9)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (2,2)-(2,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ LocalVariableReadNode (location: (2,2)-(2,4)) + │ │ ├── name: :_1 + │ │ └── depth: 0 + │ ├── call_operator_loc: ∅ + │ ├── name: :+ + │ ├── message_loc: (2,5)-(2,6) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (2,7)-(2,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (2,7)-(2,9)) + │ │ ├── name: :_2 + │ │ └── depth: 0 + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ ParenthesesNode (location: (4,0)-(4,5)) + ├── body: + │ @ StatementsNode (location: (4,1)-(4,4)) + │ └── body: (length: 1) + │ └── @ RangeNode (location: (4,1)-(4,4)) + │ ├── flags: ∅ + │ ├── left: ∅ + │ ├── right: + │ │ @ IntegerNode (location: (4,3)-(4,4)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ └── operator_loc: (4,1)-(4,3) = ".." + ├── opening_loc: (4,0)-(4,1) = "(" + └── closing_loc: (4,4)-(4,5) = ")" diff --git a/test/prism/snapshots/unparser/corpus/literal/since/30.txt b/test/prism/snapshots/unparser/corpus/literal/since/30.txt new file mode 100644 index 0000000000..300dd869f5 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/since/30.txt @@ -0,0 +1,88 @@ +@ ProgramNode (location: (1,0)-(4,17)) +├── locals: [:a, :foo] +└── statements: + @ StatementsNode (location: (1,0)-(4,17)) + └── body: (length: 4) + ├── @ MatchRequiredNode (location: (1,0)-(1,8)) + │ ├── value: + │ │ @ IntegerNode (location: (1,0)-(1,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── pattern: + │ │ @ ArrayPatternNode (location: (1,5)-(1,8)) + │ │ ├── constant: ∅ + │ │ ├── requireds: (length: 1) + │ │ │ └── @ LocalVariableTargetNode (location: (1,6)-(1,7)) + │ │ │ ├── name: :a + │ │ │ └── depth: 0 + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── opening_loc: (1,5)-(1,6) = "[" + │ │ └── closing_loc: (1,7)-(1,8) = "]" + │ └── operator_loc: (1,2)-(1,4) = "=>" + ├── @ MatchRequiredNode (location: (2,0)-(2,8)) + │ ├── value: + │ │ @ IntegerNode (location: (2,0)-(2,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── pattern: + │ │ @ ArrayPatternNode (location: (2,5)-(2,8)) + │ │ ├── constant: ∅ + │ │ ├── requireds: (length: 0) + │ │ ├── rest: + │ │ │ @ SplatNode (location: (2,6)-(2,7)) + │ │ │ ├── operator_loc: (2,6)-(2,7) = "*" + │ │ │ └── expression: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── opening_loc: (2,5)-(2,6) = "[" + │ │ └── closing_loc: (2,7)-(2,8) = "]" + │ └── operator_loc: (2,2)-(2,4) = "=>" + ├── @ MatchPredicateNode (location: (3,0)-(3,15)) + │ ├── value: + │ │ @ IntegerNode (location: (3,0)-(3,1)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── pattern: + │ │ @ FindPatternNode (location: (3,5)-(3,15)) + │ │ ├── constant: ∅ + │ │ ├── left: + │ │ │ @ SplatNode (location: (3,6)-(3,7)) + │ │ │ ├── operator_loc: (3,6)-(3,7) = "*" + │ │ │ └── expression: ∅ + │ │ ├── requireds: (length: 1) + │ │ │ └── @ IntegerNode (location: (3,9)-(3,11)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 42 + │ │ ├── right: + │ │ │ @ SplatNode (location: (3,13)-(3,14)) + │ │ │ ├── operator_loc: (3,13)-(3,14) = "*" + │ │ │ └── expression: ∅ + │ │ ├── opening_loc: (3,5)-(3,6) = "[" + │ │ └── closing_loc: (3,14)-(3,15) = "]" + │ └── operator_loc: (3,2)-(3,4) = "in" + └── @ MatchPredicateNode (location: (4,0)-(4,17)) + ├── value: + │ @ IntegerNode (location: (4,0)-(4,1)) + │ ├── flags: decimal + │ └── value: 1 + ├── pattern: + │ @ FindPatternNode (location: (4,5)-(4,17)) + │ ├── constant: ∅ + │ ├── left: + │ │ @ SplatNode (location: (4,6)-(4,7)) + │ │ ├── operator_loc: (4,6)-(4,7) = "*" + │ │ └── expression: ∅ + │ ├── requireds: (length: 1) + │ │ └── @ LocalVariableTargetNode (location: (4,9)-(4,10)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── right: + │ │ @ SplatNode (location: (4,12)-(4,16)) + │ │ ├── operator_loc: (4,12)-(4,13) = "*" + │ │ └── expression: + │ │ @ LocalVariableTargetNode (location: (4,13)-(4,16)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ ├── opening_loc: (4,5)-(4,6) = "[" + │ └── closing_loc: (4,16)-(4,17) = "]" + └── operator_loc: (4,2)-(4,4) = "in" diff --git a/test/prism/snapshots/unparser/corpus/literal/since/31.txt b/test/prism/snapshots/unparser/corpus/literal/since/31.txt new file mode 100644 index 0000000000..142a56ae83 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/since/31.txt @@ -0,0 +1,90 @@ +@ ProgramNode (location: (1,0)-(7,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(7,3)) + └── body: (length: 2) + ├── @ DefNode (location: (1,0)-(3,3)) + │ ├── name: :foo + │ ├── name_loc: (1,4)-(1,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (1,8)-(1,9)) + │ │ ├── requireds: (length: 0) + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: + │ │ @ BlockParameterNode (location: (1,8)-(1,9)) + │ │ ├── flags: ∅ + │ │ ├── name: ∅ + │ │ ├── name_loc: ∅ + │ │ └── operator_loc: (1,8)-(1,9) = "&" + │ ├── body: + │ │ @ StatementsNode (location: (2,2)-(2,7)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (2,2)-(2,7)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (2,2)-(2,5) = "bar" + │ │ ├── opening_loc: (2,5)-(2,6) = "(" + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: (2,7)-(2,8) = ")" + │ │ └── block: + │ │ @ BlockArgumentNode (location: (2,6)-(2,7)) + │ │ ├── expression: ∅ + │ │ └── operator_loc: (2,6)-(2,7) = "&" + │ ├── locals: [] + │ ├── def_keyword_loc: (1,0)-(1,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (1,7)-(1,8) = "(" + │ ├── rparen_loc: (1,9)-(1,10) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + └── @ DefNode (location: (5,0)-(7,3)) + ├── name: :foo + ├── name_loc: (5,4)-(5,7) = "foo" + ├── receiver: ∅ + ├── parameters: + │ @ ParametersNode (location: (5,8)-(5,12)) + │ ├── requireds: (length: 1) + │ │ └── @ RequiredParameterNode (location: (5,8)-(5,9)) + │ │ ├── flags: ∅ + │ │ └── name: :a + │ ├── optionals: (length: 0) + │ ├── rest: ∅ + │ ├── posts: (length: 0) + │ ├── keywords: (length: 0) + │ ├── keyword_rest: ∅ + │ └── block: + │ @ BlockParameterNode (location: (5,11)-(5,12)) + │ ├── flags: ∅ + │ ├── name: ∅ + │ ├── name_loc: ∅ + │ └── operator_loc: (5,11)-(5,12) = "&" + ├── body: + │ @ StatementsNode (location: (6,2)-(6,7)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (6,2)-(6,7)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :bar + │ ├── message_loc: (6,2)-(6,5) = "bar" + │ ├── opening_loc: (6,5)-(6,6) = "(" + │ ├── arguments: ∅ + │ ├── closing_loc: (6,7)-(6,8) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (6,6)-(6,7)) + │ ├── expression: ∅ + │ └── operator_loc: (6,6)-(6,7) = "&" + ├── locals: [:a] + ├── def_keyword_loc: (5,0)-(5,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: (5,7)-(5,8) = "(" + ├── rparen_loc: (5,12)-(5,13) = ")" + ├── equal_loc: ∅ + └── end_keyword_loc: (7,0)-(7,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/since/32.txt b/test/prism/snapshots/unparser/corpus/literal/since/32.txt new file mode 100644 index 0000000000..2b28be2fa8 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/since/32.txt @@ -0,0 +1,156 @@ +@ ProgramNode (location: (1,0)-(11,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(11,3)) + └── body: (length: 3) + ├── @ DefNode (location: (1,0)-(3,3)) + │ ├── name: :foo + │ ├── name_loc: (1,4)-(1,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (1,8)-(1,20)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (1,8)-(1,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :argument + │ │ ├── optionals: (length: 0) + │ │ ├── rest: ∅ + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: + │ │ │ @ KeywordRestParameterNode (location: (1,18)-(1,20)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (1,18)-(1,20) = "**" + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (2,2)-(2,19)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (2,2)-(2,19)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (2,2)-(2,5) = "bar" + │ │ ├── opening_loc: (2,5)-(2,6) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (2,6)-(2,18)) + │ │ │ ├── flags: contains_keywords, contains_keyword_splat + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ LocalVariableReadNode (location: (2,6)-(2,14)) + │ │ │ │ ├── name: :argument + │ │ │ │ └── depth: 0 + │ │ │ └── @ KeywordHashNode (location: (2,16)-(2,18)) + │ │ │ ├── flags: ∅ + │ │ │ └── elements: (length: 1) + │ │ │ └── @ AssocSplatNode (location: (2,16)-(2,18)) + │ │ │ ├── value: ∅ + │ │ │ └── operator_loc: (2,16)-(2,18) = "**" + │ │ ├── closing_loc: (2,18)-(2,19) = ")" + │ │ └── block: ∅ + │ ├── locals: [:argument] + │ ├── def_keyword_loc: (1,0)-(1,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (1,7)-(1,8) = "(" + │ ├── rparen_loc: (1,20)-(1,21) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ DefNode (location: (5,0)-(7,3)) + │ ├── name: :foo + │ ├── name_loc: (5,4)-(5,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: + │ │ @ ParametersNode (location: (5,8)-(5,19)) + │ │ ├── requireds: (length: 1) + │ │ │ └── @ RequiredParameterNode (location: (5,8)-(5,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── name: :argument + │ │ ├── optionals: (length: 0) + │ │ ├── rest: + │ │ │ @ RestParameterNode (location: (5,18)-(5,19)) + │ │ │ ├── flags: ∅ + │ │ │ ├── name: ∅ + │ │ │ ├── name_loc: ∅ + │ │ │ └── operator_loc: (5,18)-(5,19) = "*" + │ │ ├── posts: (length: 0) + │ │ ├── keywords: (length: 0) + │ │ ├── keyword_rest: ∅ + │ │ └── block: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (6,2)-(6,18)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (6,2)-(6,18)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (6,2)-(6,5) = "bar" + │ │ ├── opening_loc: (6,5)-(6,6) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (6,6)-(6,17)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 2) + │ │ │ ├── @ LocalVariableReadNode (location: (6,6)-(6,14)) + │ │ │ │ ├── name: :argument + │ │ │ │ └── depth: 0 + │ │ │ └── @ SplatNode (location: (6,16)-(6,17)) + │ │ │ ├── operator_loc: (6,16)-(6,17) = "*" + │ │ │ └── expression: ∅ + │ │ ├── closing_loc: (6,17)-(6,18) = ")" + │ │ └── block: ∅ + │ ├── locals: [:argument] + │ ├── def_keyword_loc: (5,0)-(5,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: (5,7)-(5,8) = "(" + │ ├── rparen_loc: (5,19)-(5,20) = ")" + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (7,0)-(7,3) = "end" + └── @ DefNode (location: (9,0)-(11,3)) + ├── name: :foo + ├── name_loc: (9,4)-(9,7) = "foo" + ├── receiver: ∅ + ├── parameters: + │ @ ParametersNode (location: (9,8)-(9,10)) + │ ├── requireds: (length: 0) + │ ├── optionals: (length: 0) + │ ├── rest: ∅ + │ ├── posts: (length: 0) + │ ├── keywords: (length: 0) + │ ├── keyword_rest: + │ │ @ KeywordRestParameterNode (location: (9,8)-(9,10)) + │ │ ├── flags: ∅ + │ │ ├── name: ∅ + │ │ ├── name_loc: ∅ + │ │ └── operator_loc: (9,8)-(9,10) = "**" + │ └── block: ∅ + ├── body: + │ @ StatementsNode (location: (10,2)-(10,20)) + │ └── body: (length: 1) + │ └── @ HashNode (location: (10,2)-(10,20)) + │ ├── opening_loc: (10,2)-(10,3) = "{" + │ ├── elements: (length: 2) + │ │ ├── @ AssocNode (location: (10,4)-(10,14)) + │ │ │ ├── key: + │ │ │ │ @ SymbolNode (location: (10,4)-(10,12)) + │ │ │ │ ├── flags: forced_us_ascii_encoding + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── value_loc: (10,4)-(10,11) = "default" + │ │ │ │ ├── closing_loc: (10,11)-(10,12) = ":" + │ │ │ │ └── unescaped: "default" + │ │ │ ├── value: + │ │ │ │ @ IntegerNode (location: (10,13)-(10,14)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ └── operator_loc: ∅ + │ │ └── @ AssocSplatNode (location: (10,16)-(10,18)) + │ │ ├── value: ∅ + │ │ └── operator_loc: (10,16)-(10,18) = "**" + │ └── closing_loc: (10,19)-(10,20) = "}" + ├── locals: [] + ├── def_keyword_loc: (9,0)-(9,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: (9,7)-(9,8) = "(" + ├── rparen_loc: (9,10)-(9,11) = ")" + ├── equal_loc: ∅ + └── end_keyword_loc: (11,0)-(11,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/literal/singletons.txt b/test/prism/snapshots/unparser/corpus/literal/singletons.txt new file mode 100644 index 0000000000..45c06f7b07 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/singletons.txt @@ -0,0 +1,9 @@ +@ ProgramNode (location: (1,0)-(4,4)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(4,4)) + └── body: (length: 4) + ├── @ FalseNode (location: (1,0)-(1,5)) + ├── @ NilNode (location: (2,0)-(2,3)) + ├── @ SelfNode (location: (3,0)-(3,4)) + └── @ TrueNode (location: (4,0)-(4,4)) diff --git a/test/prism/snapshots/unparser/corpus/literal/super.txt b/test/prism/snapshots/unparser/corpus/literal/super.txt new file mode 100644 index 0000000000..d5a7889919 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/super.txt @@ -0,0 +1,277 @@ +@ ProgramNode (location: (1,0)-(21,1)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(21,1)) + └── body: (length: 11) + ├── @ ForwardingSuperNode (location: (1,0)-(1,5)) + │ └── block: ∅ + ├── @ SuperNode (location: (2,0)-(2,7)) + │ ├── keyword_loc: (2,0)-(2,5) = "super" + │ ├── lparen_loc: (2,5)-(2,6) = "(" + │ ├── arguments: ∅ + │ ├── rparen_loc: (2,6)-(2,7) = ")" + │ └── block: ∅ + ├── @ SuperNode (location: (3,0)-(3,8)) + │ ├── keyword_loc: (3,0)-(3,5) = "super" + │ ├── lparen_loc: (3,5)-(3,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (3,6)-(3,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (3,6)-(3,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (3,6)-(3,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rparen_loc: (3,7)-(3,8) = ")" + │ └── block: ∅ + ├── @ SuperNode (location: (4,0)-(4,11)) + │ ├── keyword_loc: (4,0)-(4,5) = "super" + │ ├── lparen_loc: (4,5)-(4,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (4,6)-(4,10)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 2) + │ │ ├── @ CallNode (location: (4,6)-(4,7)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (4,6)-(4,7) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (4,9)-(4,10)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (4,9)-(4,10) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rparen_loc: (4,10)-(4,11) = ")" + │ └── block: ∅ + ├── @ SuperNode (location: (5,0)-(5,13)) + │ ├── keyword_loc: (5,0)-(5,5) = "super" + │ ├── lparen_loc: (5,5)-(5,6) = "(" + │ ├── arguments: ∅ + │ ├── rparen_loc: (5,12)-(5,13) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (5,6)-(5,12)) + │ ├── expression: + │ │ @ CallNode (location: (5,7)-(5,12)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :block + │ │ ├── message_loc: (5,7)-(5,12) = "block" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (5,6)-(5,7) = "&" + ├── @ SuperNode (location: (6,0)-(6,16)) + │ ├── keyword_loc: (6,0)-(6,5) = "super" + │ ├── lparen_loc: (6,5)-(6,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (6,6)-(6,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (6,6)-(6,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (6,6)-(6,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rparen_loc: (6,15)-(6,16) = ")" + │ └── block: + │ @ BlockArgumentNode (location: (6,9)-(6,15)) + │ ├── expression: + │ │ @ CallNode (location: (6,10)-(6,15)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :block + │ │ ├── message_loc: (6,10)-(6,15) = "block" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (6,9)-(6,10) = "&" + ├── @ SuperNode (location: (7,0)-(9,2)) + │ ├── keyword_loc: (7,0)-(7,5) = "super" + │ ├── lparen_loc: (7,5)-(7,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (7,6)-(9,1)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (7,6)-(9,1)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (7,6)-(7,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (7,8)-(9,1)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (8,2)-(8,5)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (8,2)-(8,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (8,2)-(8,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (7,8)-(7,9) = "{" + │ │ └── closing_loc: (9,0)-(9,1) = "}" + │ ├── rparen_loc: (9,1)-(9,2) = ")" + │ └── block: ∅ + ├── @ ForwardingSuperNode (location: (10,0)-(12,1)) + │ └── block: + │ @ BlockNode (location: (10,6)-(12,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (11,2)-(11,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (11,2)-(11,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (11,2)-(11,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (10,6)-(10,7) = "{" + │ └── closing_loc: (12,0)-(12,1) = "}" + ├── @ SuperNode (location: (13,0)-(15,1)) + │ ├── keyword_loc: (13,0)-(13,5) = "super" + │ ├── lparen_loc: (13,5)-(13,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (13,6)-(13,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (13,6)-(13,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (13,6)-(13,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rparen_loc: (13,7)-(13,8) = ")" + │ └── block: + │ @ BlockNode (location: (13,9)-(15,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (14,2)-(14,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (14,2)-(14,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (14,2)-(14,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (13,9)-(13,10) = "{" + │ └── closing_loc: (15,0)-(15,1) = "}" + ├── @ SuperNode (location: (16,0)-(18,1)) + │ ├── keyword_loc: (16,0)-(16,5) = "super" + │ ├── lparen_loc: (16,5)-(16,6) = "(" + │ ├── arguments: ∅ + │ ├── rparen_loc: (16,6)-(16,7) = ")" + │ └── block: + │ @ BlockNode (location: (16,8)-(18,1)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (17,2)-(17,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (17,2)-(17,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (17,2)-(17,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── opening_loc: (16,8)-(16,9) = "{" + │ └── closing_loc: (18,0)-(18,1) = "}" + └── @ SuperNode (location: (19,0)-(21,1)) + ├── keyword_loc: (19,0)-(19,5) = "super" + ├── lparen_loc: (19,5)-(19,6) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (19,6)-(19,10)) + │ ├── flags: ∅ + │ └── arguments: (length: 2) + │ ├── @ CallNode (location: (19,6)-(19,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (19,6)-(19,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── @ CallNode (location: (19,9)-(19,10)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :b + │ ├── message_loc: (19,9)-(19,10) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── rparen_loc: (19,10)-(19,11) = ")" + └── block: + @ BlockNode (location: (19,12)-(21,1)) + ├── locals: [] + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (20,2)-(20,5)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (20,2)-(20,5)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (20,2)-(20,5) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── opening_loc: (19,12)-(19,13) = "{" + └── closing_loc: (21,0)-(21,1) = "}" diff --git a/test/prism/snapshots/unparser/corpus/literal/unary.txt b/test/prism/snapshots/unparser/corpus/literal/unary.txt new file mode 100644 index 0000000000..5e9563d811 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/unary.txt @@ -0,0 +1,248 @@ +@ ProgramNode (location: (1,0)-(8,9)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(8,9)) + └── body: (length: 8) + ├── @ CallNode (location: (1,0)-(1,2)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ IntegerNode (location: (1,1)-(1,2)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── call_operator_loc: ∅ + │ ├── name: :! + │ ├── message_loc: (1,0)-(1,1) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (2,0)-(2,5)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (2,1)-(2,5)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (2,2)-(2,4)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (2,2)-(2,4)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ IntegerNode (location: (2,3)-(2,4)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 1 + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :! + │ │ │ ├── message_loc: (2,2)-(2,3) = "!" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (2,1)-(2,2) = "(" + │ │ └── closing_loc: (2,4)-(2,5) = ")" + │ ├── call_operator_loc: ∅ + │ ├── name: :! + │ ├── message_loc: (2,0)-(2,1) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (3,0)-(3,16)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (3,1)-(3,16)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (3,2)-(3,15)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (3,2)-(3,15)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ ParenthesesNode (location: (3,3)-(3,15)) + │ │ │ │ ├── body: + │ │ │ │ │ @ StatementsNode (location: (3,4)-(3,14)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ OrNode (location: (3,4)-(3,14)) + │ │ │ │ │ ├── left: + │ │ │ │ │ │ @ CallNode (location: (3,4)-(3,7)) + │ │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ │ ├── name: :foo + │ │ │ │ │ │ ├── message_loc: (3,4)-(3,7) = "foo" + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ ├── right: + │ │ │ │ │ │ @ CallNode (location: (3,11)-(3,14)) + │ │ │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ │ │ ├── receiver: ∅ + │ │ │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ │ │ ├── name: :bar + │ │ │ │ │ │ ├── message_loc: (3,11)-(3,14) = "bar" + │ │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ │ ├── arguments: ∅ + │ │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ │ └── block: ∅ + │ │ │ │ │ └── operator_loc: (3,8)-(3,10) = "||" + │ │ │ │ ├── opening_loc: (3,3)-(3,4) = "(" + │ │ │ │ └── closing_loc: (3,14)-(3,15) = ")" + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :! + │ │ │ ├── message_loc: (3,2)-(3,3) = "!" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (3,1)-(3,2) = "(" + │ │ └── closing_loc: (3,15)-(3,16) = ")" + │ ├── call_operator_loc: ∅ + │ ├── name: :! + │ ├── message_loc: (3,0)-(3,1) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (4,0)-(4,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (4,1)-(4,9)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ ParenthesesNode (location: (4,1)-(4,5)) + │ │ │ ├── body: + │ │ │ │ @ StatementsNode (location: (4,2)-(4,4)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (4,2)-(4,4)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ ├── receiver: + │ │ │ │ │ @ IntegerNode (location: (4,3)-(4,4)) + │ │ │ │ │ ├── flags: decimal + │ │ │ │ │ └── value: 1 + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :! + │ │ │ │ ├── message_loc: (4,2)-(4,3) = "!" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── opening_loc: (4,1)-(4,2) = "(" + │ │ │ └── closing_loc: (4,4)-(4,5) = ")" + │ │ ├── call_operator_loc: (4,5)-(4,6) = "." + │ │ ├── name: :baz + │ │ ├── message_loc: (4,6)-(4,9) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :! + │ ├── message_loc: (4,0)-(4,1) = "!" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (5,0)-(5,2)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (5,1)-(5,2)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (5,1)-(5,2) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :~ + │ ├── message_loc: (5,0)-(5,1) = "~" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (6,0)-(6,2)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (6,1)-(6,2)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (6,1)-(6,2) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :-@ + │ ├── message_loc: (6,0)-(6,1) = "-" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (7,0)-(7,2)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (7,1)-(7,2)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (7,1)-(7,2) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :+@ + │ ├── message_loc: (7,0)-(7,1) = "+" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ CallNode (location: (8,0)-(8,9)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (8,1)-(8,9)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ ParenthesesNode (location: (8,1)-(8,5)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (8,2)-(8,4)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (8,2)-(8,4)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (8,3)-(8,4)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (8,3)-(8,4) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :-@ + │ │ │ ├── message_loc: (8,2)-(8,3) = "-" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (8,1)-(8,2) = "(" + │ │ └── closing_loc: (8,4)-(8,5) = ")" + │ ├── call_operator_loc: (8,5)-(8,6) = "." + │ ├── name: :foo + │ ├── message_loc: (8,6)-(8,9) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: ∅ + ├── name: :-@ + ├── message_loc: (8,0)-(8,1) = "-" + ├── opening_loc: ∅ + ├── arguments: ∅ + ├── closing_loc: ∅ + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/literal/undef.txt b/test/prism/snapshots/unparser/corpus/literal/undef.txt new file mode 100644 index 0000000000..282cbe8f87 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/undef.txt @@ -0,0 +1,29 @@ +@ ProgramNode (location: (1,0)-(2,16)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(2,16)) + └── body: (length: 2) + ├── @ UndefNode (location: (1,0)-(1,10)) + │ ├── names: (length: 1) + │ │ └── @ SymbolNode (location: (1,6)-(1,10)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (1,6)-(1,7) = ":" + │ │ ├── value_loc: (1,7)-(1,10) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ └── keyword_loc: (1,0)-(1,5) = "undef" + └── @ UndefNode (location: (2,0)-(2,16)) + ├── names: (length: 2) + │ ├── @ SymbolNode (location: (2,6)-(2,10)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: (2,6)-(2,7) = ":" + │ │ ├── value_loc: (2,7)-(2,10) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ └── @ SymbolNode (location: (2,12)-(2,16)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (2,12)-(2,13) = ":" + │ ├── value_loc: (2,13)-(2,16) = "bar" + │ ├── closing_loc: ∅ + │ └── unescaped: "bar" + └── keyword_loc: (2,0)-(2,5) = "undef" diff --git a/test/prism/snapshots/unparser/corpus/literal/variables.txt b/test/prism/snapshots/unparser/corpus/literal/variables.txt new file mode 100644 index 0000000000..9ae8ad1207 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/variables.txt @@ -0,0 +1,49 @@ +@ ProgramNode (location: (1,0)-(10,17)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(10,17)) + └── body: (length: 10) + ├── @ CallNode (location: (1,0)-(1,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (1,0)-(1,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ InstanceVariableReadNode (location: (2,0)-(2,2)) + │ └── name: :@a + ├── @ ClassVariableReadNode (location: (3,0)-(3,3)) + │ └── name: :@@a + ├── @ GlobalVariableReadNode (location: (4,0)-(4,2)) + │ └── name: :$a + ├── @ NumberedReferenceReadNode (location: (5,0)-(5,2)) + │ └── number: 1 + ├── @ BackReferenceReadNode (location: (6,0)-(6,2)) + │ └── name: :$` + ├── @ ConstantReadNode (location: (7,0)-(7,5)) + │ └── name: :CONST + ├── @ ConstantPathNode (location: (8,0)-(8,13)) + │ ├── parent: + │ │ @ ConstantReadNode (location: (8,0)-(8,6)) + │ │ └── name: :SCOPED + │ ├── name: :CONST + │ ├── delimiter_loc: (8,6)-(8,8) = "::" + │ └── name_loc: (8,8)-(8,13) = "CONST" + ├── @ ConstantPathNode (location: (9,0)-(9,10)) + │ ├── parent: ∅ + │ ├── name: :TOPLEVEL + │ ├── delimiter_loc: (9,0)-(9,2) = "::" + │ └── name_loc: (9,2)-(9,10) = "TOPLEVEL" + └── @ ConstantPathNode (location: (10,0)-(10,17)) + ├── parent: + │ @ ConstantPathNode (location: (10,0)-(10,10)) + │ ├── parent: ∅ + │ ├── name: :TOPLEVEL + │ ├── delimiter_loc: (10,0)-(10,2) = "::" + │ └── name_loc: (10,2)-(10,10) = "TOPLEVEL" + ├── name: :CONST + ├── delimiter_loc: (10,10)-(10,12) = "::" + └── name_loc: (10,12)-(10,17) = "CONST" diff --git a/test/prism/snapshots/unparser/corpus/literal/while.txt b/test/prism/snapshots/unparser/corpus/literal/while.txt new file mode 100644 index 0000000000..0f752f3392 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/while.txt @@ -0,0 +1,704 @@ +@ ProgramNode (location: (1,0)-(73,3)) +├── locals: [:x] +└── statements: + @ StatementsNode (location: (1,0)-(73,3)) + └── body: (length: 17) + ├── @ ModuleNode (location: (1,0)-(7,3)) + │ ├── locals: [] + │ ├── module_keyword_loc: (1,0)-(1,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (1,7)-(1,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (2,2)-(6,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (2,2)-(6,3)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (2,2)-(2,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (2,6)-(6,3)) + │ │ ├── locals: [:bar, :foo] + │ │ ├── parameters: + │ │ │ @ BlockParametersNode (location: (2,8)-(2,13)) + │ │ │ ├── parameters: + │ │ │ │ @ ParametersNode (location: (2,9)-(2,12)) + │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ └── @ RequiredParameterNode (location: (2,9)-(2,12)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :bar + │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── locals: (length: 0) + │ │ │ ├── opening_loc: (2,8)-(2,9) = "|" + │ │ │ └── closing_loc: (2,12)-(2,13) = "|" + │ │ ├── body: + │ │ │ @ StatementsNode (location: (3,4)-(5,7)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ WhileNode (location: (3,4)-(5,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── keyword_loc: (3,4)-(3,9) = "while" + │ │ │ ├── closing_loc: (5,4)-(5,7) = "end" + │ │ │ ├── predicate: + │ │ │ │ @ CallNode (location: (3,10)-(3,13)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (3,10)-(3,13) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (4,6)-(4,15)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableWriteNode (location: (4,6)-(4,15)) + │ │ │ ├── name: :foo + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (4,6)-(4,9) = "foo" + │ │ │ ├── value: + │ │ │ │ @ LocalVariableReadNode (location: (4,12)-(4,15)) + │ │ │ │ ├── name: :bar + │ │ │ │ └── depth: 0 + │ │ │ └── operator_loc: (4,10)-(4,11) = "=" + │ │ ├── opening_loc: (2,6)-(2,7) = "{" + │ │ └── closing_loc: (6,2)-(6,3) = "}" + │ ├── end_keyword_loc: (7,0)-(7,3) = "end" + │ └── name: :A + ├── @ DefNode (location: (9,0)-(11,3)) + │ ├── name: :foo + │ ├── name_loc: (9,4)-(9,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (10,2)-(10,28)) + │ │ └── body: (length: 1) + │ │ └── @ WhileNode (location: (10,2)-(10,28)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (10,12)-(10,17) = "while" + │ │ ├── closing_loc: ∅ + │ │ ├── predicate: + │ │ │ @ CallNode (location: (10,18)-(10,28)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ LocalVariableReadNode (location: (10,18)-(10,21)) + │ │ │ │ ├── name: :foo + │ │ │ │ └── depth: 0 + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :!= + │ │ │ ├── message_loc: (10,22)-(10,24) = "!=" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (10,25)-(10,28)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (10,25)-(10,28)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (10,25)-(10,28) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (10,2)-(10,11)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableWriteNode (location: (10,2)-(10,11)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (10,2)-(10,5) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (10,8)-(10,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (10,8)-(10,11) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (10,6)-(10,7) = "=" + │ ├── locals: [:foo] + │ ├── def_keyword_loc: (9,0)-(9,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (11,0)-(11,3) = "end" + ├── @ ModuleNode (location: (13,0)-(15,3)) + │ ├── locals: [:foo] + │ ├── module_keyword_loc: (13,0)-(13,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (13,7)-(13,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (14,2)-(14,21)) + │ │ └── body: (length: 1) + │ │ └── @ WhileNode (location: (14,2)-(14,21)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (14,12)-(14,17) = "while" + │ │ ├── closing_loc: ∅ + │ │ ├── predicate: + │ │ │ @ LocalVariableReadNode (location: (14,18)-(14,21)) + │ │ │ ├── name: :foo + │ │ │ └── depth: 0 + │ │ └── statements: + │ │ @ StatementsNode (location: (14,2)-(14,11)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableWriteNode (location: (14,2)-(14,11)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (14,2)-(14,5) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (14,8)-(14,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (14,8)-(14,11) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (14,6)-(14,7) = "=" + │ ├── end_keyword_loc: (15,0)-(15,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (17,0)-(19,3)) + │ ├── locals: [:foo] + │ ├── module_keyword_loc: (17,0)-(17,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (17,7)-(17,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (18,2)-(18,21)) + │ │ └── body: (length: 1) + │ │ └── @ UntilNode (location: (18,2)-(18,21)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (18,12)-(18,17) = "until" + │ │ ├── closing_loc: ∅ + │ │ ├── predicate: + │ │ │ @ LocalVariableReadNode (location: (18,18)-(18,21)) + │ │ │ ├── name: :foo + │ │ │ └── depth: 0 + │ │ └── statements: + │ │ @ StatementsNode (location: (18,2)-(18,11)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableWriteNode (location: (18,2)-(18,11)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (18,2)-(18,5) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (18,8)-(18,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (18,8)-(18,11) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (18,6)-(18,7) = "=" + │ ├── end_keyword_loc: (19,0)-(19,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (21,0)-(25,3)) + │ ├── locals: [:foo] + │ ├── module_keyword_loc: (21,0)-(21,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (21,7)-(21,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (22,2)-(24,5)) + │ │ └── body: (length: 1) + │ │ └── @ WhileNode (location: (22,2)-(24,5)) + │ │ ├── flags: ∅ + │ │ ├── keyword_loc: (22,2)-(22,7) = "while" + │ │ ├── closing_loc: (24,2)-(24,5) = "end" + │ │ ├── predicate: + │ │ │ @ CallNode (location: (22,8)-(22,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (22,8)-(22,11) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── statements: + │ │ @ StatementsNode (location: (23,4)-(23,13)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableWriteNode (location: (23,4)-(23,13)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (23,4)-(23,7) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (23,10)-(23,13)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :bar + │ │ │ ├── message_loc: (23,10)-(23,13) = "bar" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (23,8)-(23,9) = "=" + │ ├── end_keyword_loc: (25,0)-(25,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (27,0)-(33,3)) + │ ├── locals: [] + │ ├── module_keyword_loc: (27,0)-(27,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (27,7)-(27,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (28,2)-(32,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (28,2)-(32,3)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :each + │ │ ├── message_loc: (28,2)-(28,6) = "each" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (28,7)-(32,3)) + │ │ ├── locals: [:baz, :foo] + │ │ ├── parameters: + │ │ │ @ BlockParametersNode (location: (28,9)-(28,14)) + │ │ │ ├── parameters: + │ │ │ │ @ ParametersNode (location: (28,10)-(28,13)) + │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ └── @ RequiredParameterNode (location: (28,10)-(28,13)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :baz + │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── locals: (length: 0) + │ │ │ ├── opening_loc: (28,9)-(28,10) = "|" + │ │ │ └── closing_loc: (28,13)-(28,14) = "|" + │ │ ├── body: + │ │ │ @ StatementsNode (location: (29,4)-(31,7)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ WhileNode (location: (29,4)-(31,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── keyword_loc: (29,4)-(29,9) = "while" + │ │ │ ├── closing_loc: (31,4)-(31,7) = "end" + │ │ │ ├── predicate: + │ │ │ │ @ CallNode (location: (29,10)-(29,13)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (29,10)-(29,13) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (30,6)-(30,15)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableWriteNode (location: (30,6)-(30,15)) + │ │ │ ├── name: :foo + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (30,6)-(30,9) = "foo" + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (30,12)-(30,15)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (30,12)-(30,15) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (30,10)-(30,11) = "=" + │ │ ├── opening_loc: (28,7)-(28,8) = "{" + │ │ └── closing_loc: (32,2)-(32,3) = "}" + │ ├── end_keyword_loc: (33,0)-(33,3) = "end" + │ └── name: :A + ├── @ ModuleNode (location: (35,0)-(41,3)) + │ ├── locals: [] + │ ├── module_keyword_loc: (35,0)-(35,6) = "module" + │ ├── constant_path: + │ │ @ ConstantReadNode (location: (35,7)-(35,8)) + │ │ └── name: :A + │ ├── body: + │ │ @ StatementsNode (location: (36,2)-(40,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (36,2)-(40,3)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :each + │ │ ├── message_loc: (36,2)-(36,6) = "each" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (36,7)-(40,3)) + │ │ ├── locals: [:foo] + │ │ ├── parameters: + │ │ │ @ BlockParametersNode (location: (36,9)-(36,14)) + │ │ │ ├── parameters: + │ │ │ │ @ ParametersNode (location: (36,10)-(36,13)) + │ │ │ │ ├── requireds: (length: 1) + │ │ │ │ │ └── @ RequiredParameterNode (location: (36,10)-(36,13)) + │ │ │ │ │ ├── flags: ∅ + │ │ │ │ │ └── name: :foo + │ │ │ │ ├── optionals: (length: 0) + │ │ │ │ ├── rest: ∅ + │ │ │ │ ├── posts: (length: 0) + │ │ │ │ ├── keywords: (length: 0) + │ │ │ │ ├── keyword_rest: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── locals: (length: 0) + │ │ │ ├── opening_loc: (36,9)-(36,10) = "|" + │ │ │ └── closing_loc: (36,13)-(36,14) = "|" + │ │ ├── body: + │ │ │ @ StatementsNode (location: (37,4)-(39,7)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ WhileNode (location: (37,4)-(39,7)) + │ │ │ ├── flags: ∅ + │ │ │ ├── keyword_loc: (37,4)-(37,9) = "while" + │ │ │ ├── closing_loc: (39,4)-(39,7) = "end" + │ │ │ ├── predicate: + │ │ │ │ @ LocalVariableReadNode (location: (37,10)-(37,13)) + │ │ │ │ ├── name: :foo + │ │ │ │ └── depth: 0 + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (38,6)-(38,15)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ LocalVariableWriteNode (location: (38,6)-(38,15)) + │ │ │ ├── name: :foo + │ │ │ ├── depth: 0 + │ │ │ ├── name_loc: (38,6)-(38,9) = "foo" + │ │ │ ├── value: + │ │ │ │ @ CallNode (location: (38,12)-(38,15)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :bar + │ │ │ │ ├── message_loc: (38,12)-(38,15) = "bar" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (38,10)-(38,11) = "=" + │ │ ├── opening_loc: (36,7)-(36,8) = "{" + │ │ └── closing_loc: (40,2)-(40,3) = "}" + │ ├── end_keyword_loc: (41,0)-(41,3) = "end" + │ └── name: :A + ├── @ LocalVariableWriteNode (location: (42,0)-(44,14)) + │ ├── name: :x + │ ├── depth: 0 + │ ├── name_loc: (42,0)-(42,1) = "x" + │ ├── value: + │ │ @ ParenthesesNode (location: (42,4)-(44,14)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (42,5)-(44,13)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ WhileNode (location: (42,5)-(44,13)) + │ │ │ ├── flags: begin_modifier + │ │ │ ├── keyword_loc: (44,4)-(44,9) = "while" + │ │ │ ├── closing_loc: ∅ + │ │ │ ├── predicate: + │ │ │ │ @ CallNode (location: (44,10)-(44,13)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :baz + │ │ │ │ ├── message_loc: (44,10)-(44,13) = "baz" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── statements: + │ │ │ @ StatementsNode (location: (42,5)-(44,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ BeginNode (location: (42,5)-(44,3)) + │ │ │ ├── begin_keyword_loc: (42,5)-(42,10) = "begin" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (43,2)-(43,5)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ CallNode (location: (43,2)-(43,5)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :foo + │ │ │ │ ├── message_loc: (43,2)-(43,5) = "foo" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── rescue_clause: ∅ + │ │ │ ├── else_clause: ∅ + │ │ │ ├── ensure_clause: ∅ + │ │ │ └── end_keyword_loc: (44,0)-(44,3) = "end" + │ │ ├── opening_loc: (42,4)-(42,5) = "(" + │ │ └── closing_loc: (44,13)-(44,14) = ")" + │ └── operator_loc: (42,2)-(42,3) = "=" + ├── @ WhileNode (location: (45,0)-(47,13)) + │ ├── flags: begin_modifier + │ ├── keyword_loc: (47,4)-(47,9) = "while" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (47,10)-(47,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (47,10)-(47,13) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── statements: + │ @ StatementsNode (location: (45,0)-(47,3)) + │ └── body: (length: 1) + │ └── @ BeginNode (location: (45,0)-(47,3)) + │ ├── begin_keyword_loc: (45,0)-(45,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (46,2)-(46,5)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (46,2)-(46,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (46,2)-(46,5) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (47,0)-(47,3) = "end" + ├── @ UntilNode (location: (48,0)-(51,13)) + │ ├── flags: begin_modifier + │ ├── keyword_loc: (51,4)-(51,9) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (51,10)-(51,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (51,10)-(51,13) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── statements: + │ @ StatementsNode (location: (48,0)-(51,3)) + │ └── body: (length: 1) + │ └── @ BeginNode (location: (48,0)-(51,3)) + │ ├── begin_keyword_loc: (48,0)-(48,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (49,2)-(50,5)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (49,2)-(49,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (49,2)-(49,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (50,2)-(50,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (50,2)-(50,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (51,0)-(51,3) = "end" + ├── @ WhileNode (location: (52,0)-(55,13)) + │ ├── flags: begin_modifier + │ ├── keyword_loc: (55,4)-(55,9) = "while" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (55,10)-(55,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :baz + │ │ ├── message_loc: (55,10)-(55,13) = "baz" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── statements: + │ @ StatementsNode (location: (52,0)-(55,3)) + │ └── body: (length: 1) + │ └── @ BeginNode (location: (52,0)-(55,3)) + │ ├── begin_keyword_loc: (52,0)-(52,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (53,2)-(54,5)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (53,2)-(53,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (53,2)-(53,5) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ CallNode (location: (54,2)-(54,5)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (54,2)-(54,5) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (55,0)-(55,3) = "end" + ├── @ WhileNode (location: (56,0)-(57,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (56,0)-(56,5) = "while" + │ ├── closing_loc: (57,0)-(57,3) = "end" + │ ├── predicate: + │ │ @ FalseNode (location: (56,6)-(56,11)) + │ └── statements: ∅ + ├── @ WhileNode (location: (58,0)-(60,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (58,0)-(58,5) = "while" + │ ├── closing_loc: (60,0)-(60,3) = "end" + │ ├── predicate: + │ │ @ FalseNode (location: (58,6)-(58,11)) + │ └── statements: + │ @ StatementsNode (location: (59,2)-(59,3)) + │ └── body: (length: 1) + │ └── @ IntegerNode (location: (59,2)-(59,3)) + │ ├── flags: decimal + │ └── value: 3 + ├── @ WhileNode (location: (61,0)-(64,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (61,0)-(61,5) = "while" + │ ├── closing_loc: (64,0)-(64,3) = "end" + │ ├── predicate: + │ │ @ ParenthesesNode (location: (61,6)-(62,2)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (61,7)-(62,1)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (61,7)-(62,1)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :foo + │ │ │ ├── message_loc: (61,7)-(61,10) = "foo" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (61,11)-(62,1)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (61,11)-(61,12) = "{" + │ │ │ └── closing_loc: (62,0)-(62,1) = "}" + │ │ ├── opening_loc: (61,6)-(61,7) = "(" + │ │ └── closing_loc: (62,1)-(62,2) = ")" + │ └── statements: + │ @ StatementsNode (location: (63,2)-(63,7)) + │ └── body: (length: 1) + │ └── @ SymbolNode (location: (63,2)-(63,7)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (63,2)-(63,3) = ":" + │ ├── value_loc: (63,3)-(63,7) = "body" + │ ├── closing_loc: ∅ + │ └── unescaped: "body" + ├── @ UntilNode (location: (65,0)-(66,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (65,0)-(65,5) = "until" + │ ├── closing_loc: (66,0)-(66,3) = "end" + │ ├── predicate: + │ │ @ FalseNode (location: (65,6)-(65,11)) + │ └── statements: ∅ + ├── @ UntilNode (location: (67,0)-(69,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (67,0)-(67,5) = "until" + │ ├── closing_loc: (69,0)-(69,3) = "end" + │ ├── predicate: + │ │ @ FalseNode (location: (67,6)-(67,11)) + │ └── statements: + │ @ StatementsNode (location: (68,2)-(68,3)) + │ └── body: (length: 1) + │ └── @ IntegerNode (location: (68,2)-(68,3)) + │ ├── flags: decimal + │ └── value: 3 + └── @ UntilNode (location: (70,0)-(73,3)) + ├── flags: ∅ + ├── keyword_loc: (70,0)-(70,5) = "until" + ├── closing_loc: (73,0)-(73,3) = "end" + ├── predicate: + │ @ ParenthesesNode (location: (70,6)-(71,2)) + │ ├── body: + │ │ @ StatementsNode (location: (70,7)-(71,1)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (70,7)-(71,1)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :foo + │ │ ├── message_loc: (70,7)-(70,10) = "foo" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (70,11)-(71,1)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (70,11)-(70,12) = "{" + │ │ └── closing_loc: (71,0)-(71,1) = "}" + │ ├── opening_loc: (70,6)-(70,7) = "(" + │ └── closing_loc: (71,1)-(71,2) = ")" + └── statements: + @ StatementsNode (location: (72,2)-(72,7)) + └── body: (length: 1) + └── @ SymbolNode (location: (72,2)-(72,7)) + ├── flags: forced_us_ascii_encoding + ├── opening_loc: (72,2)-(72,3) = ":" + ├── value_loc: (72,3)-(72,7) = "body" + ├── closing_loc: ∅ + └── unescaped: "body" diff --git a/test/prism/snapshots/unparser/corpus/literal/yield.txt b/test/prism/snapshots/unparser/corpus/literal/yield.txt new file mode 100644 index 0000000000..4d2b272e35 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/literal/yield.txt @@ -0,0 +1,56 @@ +@ ProgramNode (location: (1,0)-(3,11)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(3,11)) + └── body: (length: 3) + ├── @ YieldNode (location: (1,0)-(1,5)) + │ ├── keyword_loc: (1,0)-(1,5) = "yield" + │ ├── lparen_loc: ∅ + │ ├── arguments: ∅ + │ └── rparen_loc: ∅ + ├── @ YieldNode (location: (2,0)-(2,8)) + │ ├── keyword_loc: (2,0)-(2,5) = "yield" + │ ├── lparen_loc: (2,5)-(2,6) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (2,6)-(2,7)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (2,6)-(2,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (2,6)-(2,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── rparen_loc: (2,7)-(2,8) = ")" + └── @ YieldNode (location: (3,0)-(3,11)) + ├── keyword_loc: (3,0)-(3,5) = "yield" + ├── lparen_loc: (3,5)-(3,6) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (3,6)-(3,10)) + │ ├── flags: ∅ + │ └── arguments: (length: 2) + │ ├── @ CallNode (location: (3,6)-(3,7)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (3,6)-(3,7) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── @ CallNode (location: (3,9)-(3,10)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :b + │ ├── message_loc: (3,9)-(3,10) = "b" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── rparen_loc: (3,10)-(3,11) = ")" diff --git a/test/prism/snapshots/unparser/corpus/semantic/and.txt b/test/prism/snapshots/unparser/corpus/semantic/and.txt new file mode 100644 index 0000000000..bc9d674e44 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/and.txt @@ -0,0 +1,235 @@ +@ ProgramNode (location: (1,0)-(8,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(8,3)) + └── body: (length: 4) + ├── @ OrNode (location: (1,0)-(1,14)) + │ ├── left: + │ │ @ RangeNode (location: (1,0)-(1,5)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (1,0)-(1,1)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (1,0)-(1,1) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (1,4)-(1,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (1,4)-(1,5) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (1,1)-(1,4) = "..." + │ ├── right: + │ │ @ RangeNode (location: (1,9)-(1,14)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (1,9)-(1,10)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (1,9)-(1,10) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (1,13)-(1,14)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (1,13)-(1,14) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (1,10)-(1,13) = "..." + │ └── operator_loc: (1,6)-(1,8) = "or" + ├── @ AndNode (location: (2,0)-(2,15)) + │ ├── left: + │ │ @ RangeNode (location: (2,0)-(2,5)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (2,0)-(2,1)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (2,0)-(2,1) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (2,4)-(2,5)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (2,4)-(2,5) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (2,1)-(2,4) = "..." + │ ├── right: + │ │ @ RangeNode (location: (2,10)-(2,15)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (2,10)-(2,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (2,10)-(2,11) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (2,14)-(2,15)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (2,14)-(2,15) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (2,11)-(2,14) = "..." + │ └── operator_loc: (2,6)-(2,9) = "and" + ├── @ IfNode (location: (4,0)-(5,3)) + │ ├── if_keyword_loc: (4,0)-(4,2) = "if" + │ ├── predicate: + │ │ @ OrNode (location: (4,3)-(4,17)) + │ │ ├── left: + │ │ │ @ FlipFlopNode (location: (4,3)-(4,8)) + │ │ │ ├── flags: exclude_end + │ │ │ ├── left: + │ │ │ │ @ CallNode (location: (4,3)-(4,4)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (4,3)-(4,4) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── right: + │ │ │ │ @ CallNode (location: (4,7)-(4,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (4,7)-(4,8) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (4,4)-(4,7) = "..." + │ │ ├── right: + │ │ │ @ FlipFlopNode (location: (4,12)-(4,17)) + │ │ │ ├── flags: exclude_end + │ │ │ ├── left: + │ │ │ │ @ CallNode (location: (4,12)-(4,13)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :c + │ │ │ │ ├── message_loc: (4,12)-(4,13) = "c" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── right: + │ │ │ │ @ CallNode (location: (4,16)-(4,17)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :d + │ │ │ │ ├── message_loc: (4,16)-(4,17) = "d" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ └── operator_loc: (4,13)-(4,16) = "..." + │ │ └── operator_loc: (4,9)-(4,11) = "or" + │ ├── then_keyword_loc: ∅ + │ ├── statements: ∅ + │ ├── consequent: ∅ + │ └── end_keyword_loc: (5,0)-(5,3) = "end" + └── @ IfNode (location: (7,0)-(8,3)) + ├── if_keyword_loc: (7,0)-(7,2) = "if" + ├── predicate: + │ @ AndNode (location: (7,3)-(7,18)) + │ ├── left: + │ │ @ FlipFlopNode (location: (7,3)-(7,8)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (7,3)-(7,4)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (7,3)-(7,4) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (7,7)-(7,8)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (7,7)-(7,8) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (7,4)-(7,7) = "..." + │ ├── right: + │ │ @ FlipFlopNode (location: (7,13)-(7,18)) + │ │ ├── flags: exclude_end + │ │ ├── left: + │ │ │ @ CallNode (location: (7,13)-(7,14)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (7,13)-(7,14) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (7,17)-(7,18)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (7,17)-(7,18) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (7,14)-(7,17) = "..." + │ └── operator_loc: (7,9)-(7,12) = "and" + ├── then_keyword_loc: ∅ + ├── statements: ∅ + ├── consequent: ∅ + └── end_keyword_loc: (8,0)-(8,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/block.txt b/test/prism/snapshots/unparser/corpus/semantic/block.txt new file mode 100644 index 0000000000..b9aa6b2184 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/block.txt @@ -0,0 +1,191 @@ +@ ProgramNode (location: (1,0)-(26,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(26,3)) + └── body: (length: 6) + ├── @ CallNode (location: (1,0)-(2,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (1,4)-(2,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: ∅ + │ ├── opening_loc: (1,4)-(1,6) = "do" + │ └── closing_loc: (2,0)-(2,3) = "end" + ├── @ CallNode (location: (4,0)-(6,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (4,0)-(4,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (4,4)-(6,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ BeginNode (location: (4,4)-(6,3)) + │ │ ├── begin_keyword_loc: ∅ + │ │ ├── statements: ∅ + │ │ ├── rescue_clause: + │ │ │ @ RescueNode (location: (5,0)-(5,6)) + │ │ │ ├── keyword_loc: (5,0)-(5,6) = "rescue" + │ │ │ ├── exceptions: (length: 0) + │ │ │ ├── operator_loc: ∅ + │ │ │ ├── reference: ∅ + │ │ │ ├── statements: ∅ + │ │ │ └── consequent: ∅ + │ │ ├── else_clause: ∅ + │ │ ├── ensure_clause: ∅ + │ │ └── end_keyword_loc: (6,0)-(6,3) = "end" + │ ├── opening_loc: (4,4)-(4,6) = "do" + │ └── closing_loc: (6,0)-(6,3) = "end" + ├── @ CallNode (location: (8,0)-(11,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (8,0)-(8,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (8,4)-(11,3)) + │ ├── locals: [] + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (9,2)-(10,5)) + │ │ └── body: (length: 2) + │ │ ├── @ RescueModifierNode (location: (9,2)-(9,16)) + │ │ │ ├── expression: + │ │ │ │ @ NilNode (location: (9,2)-(9,5)) + │ │ │ ├── keyword_loc: (9,6)-(9,12) = "rescue" + │ │ │ └── rescue_expression: + │ │ │ @ NilNode (location: (9,13)-(9,16)) + │ │ └── @ NilNode (location: (10,2)-(10,5)) + │ ├── opening_loc: (8,4)-(8,6) = "do" + │ └── closing_loc: (11,0)-(11,3) = "end" + ├── @ CallNode (location: (13,0)-(14,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (13,0)-(13,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: + │ @ BlockNode (location: (13,4)-(14,3)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (13,7)-(13,10)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (13,8)-(13,9)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (13,8)-(13,9)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (13,7)-(13,8) = "|" + │ │ └── closing_loc: (13,9)-(13,10) = "|" + │ ├── body: ∅ + │ ├── opening_loc: (13,4)-(13,6) = "do" + │ └── closing_loc: (14,0)-(14,3) = "end" + ├── @ CallNode (location: (16,0)-(20,3)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (16,0)-(16,3) = "foo" + │ ├── opening_loc: (16,3)-(16,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (16,4)-(16,10)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ StringNode (location: (16,4)-(16,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (16,4)-(16,10) = "<<-DOC" + │ │ ├── content_loc: (17,0)-(18,0) = " b\n" + │ │ ├── closing_loc: (18,0)-(19,0) = "DOC\n" + │ │ └── unescaped: " b\n" + │ ├── closing_loc: (16,10)-(16,11) = ")" + │ └── block: + │ @ BlockNode (location: (16,12)-(20,3)) + │ ├── locals: [:a] + │ ├── parameters: + │ │ @ BlockParametersNode (location: (16,15)-(16,18)) + │ │ ├── parameters: + │ │ │ @ ParametersNode (location: (16,16)-(16,17)) + │ │ │ ├── requireds: (length: 1) + │ │ │ │ └── @ RequiredParameterNode (location: (16,16)-(16,17)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── name: :a + │ │ │ ├── optionals: (length: 0) + │ │ │ ├── rest: ∅ + │ │ │ ├── posts: (length: 0) + │ │ │ ├── keywords: (length: 0) + │ │ │ ├── keyword_rest: ∅ + │ │ │ └── block: ∅ + │ │ ├── locals: (length: 0) + │ │ ├── opening_loc: (16,15)-(16,16) = "|" + │ │ └── closing_loc: (16,17)-(16,18) = "|" + │ ├── body: + │ │ @ StatementsNode (location: (19,2)-(19,3)) + │ │ └── body: (length: 1) + │ │ └── @ LocalVariableReadNode (location: (19,2)-(19,3)) + │ │ ├── name: :a + │ │ └── depth: 0 + │ ├── opening_loc: (16,12)-(16,14) = "do" + │ └── closing_loc: (20,0)-(20,3) = "end" + └── @ CallNode (location: (22,0)-(26,3)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :foo + ├── message_loc: (22,0)-(22,3) = "foo" + ├── opening_loc: (22,3)-(22,4) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (22,4)-(22,10)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ StringNode (location: (22,4)-(22,10)) + │ ├── flags: ∅ + │ ├── opening_loc: (22,4)-(22,10) = "<<-DOC" + │ ├── content_loc: (23,0)-(24,0) = " b\n" + │ ├── closing_loc: (24,0)-(25,0) = "DOC\n" + │ └── unescaped: " b\n" + ├── closing_loc: (22,10)-(22,11) = ")" + └── block: + @ BlockNode (location: (22,12)-(26,3)) + ├── locals: [] + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (25,2)-(25,3)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (25,2)-(25,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (25,2)-(25,3) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── opening_loc: (22,12)-(22,14) = "do" + └── closing_loc: (26,0)-(26,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/def.txt b/test/prism/snapshots/unparser/corpus/semantic/def.txt new file mode 100644 index 0000000000..b44983c2f3 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/def.txt @@ -0,0 +1,90 @@ +@ ProgramNode (location: (1,0)-(7,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(7,3)) + └── body: (length: 2) + ├── @ DefNode (location: (1,0)-(3,3)) + │ ├── name: :foo + │ ├── name_loc: (1,4)-(1,7) = "foo" + │ ├── receiver: ∅ + │ ├── parameters: ∅ + │ ├── body: + │ │ @ StatementsNode (location: (2,2)-(2,9)) + │ │ └── body: (length: 1) + │ │ └── @ ParenthesesNode (location: (2,2)-(2,9)) + │ │ ├── body: + │ │ │ @ StatementsNode (location: (2,3)-(2,8)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (2,3)-(2,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (2,3)-(2,4)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (2,3)-(2,4) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :- + │ │ │ ├── message_loc: (2,5)-(2,6) = "-" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (2,7)-(2,8)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (2,7)-(2,8)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (2,7)-(2,8) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (2,2)-(2,3) = "(" + │ │ └── closing_loc: (2,8)-(2,9) = ")" + │ ├── locals: [] + │ ├── def_keyword_loc: (1,0)-(1,3) = "def" + │ ├── operator_loc: ∅ + │ ├── lparen_loc: ∅ + │ ├── rparen_loc: ∅ + │ ├── equal_loc: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + └── @ DefNode (location: (5,0)-(7,3)) + ├── name: :foo + ├── name_loc: (5,4)-(5,7) = "foo" + ├── receiver: ∅ + ├── parameters: ∅ + ├── body: + │ @ StatementsNode (location: (6,2)-(6,20)) + │ └── body: (length: 1) + │ └── @ RescueModifierNode (location: (6,2)-(6,20)) + │ ├── expression: + │ │ @ CallNode (location: (6,2)-(6,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (6,2)-(6,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── keyword_loc: (6,4)-(6,10) = "rescue" + │ └── rescue_expression: + │ @ ConstantReadNode (location: (6,11)-(6,20)) + │ └── name: :Exception + ├── locals: [] + ├── def_keyword_loc: (5,0)-(5,3) = "def" + ├── operator_loc: ∅ + ├── lparen_loc: ∅ + ├── rparen_loc: ∅ + ├── equal_loc: ∅ + └── end_keyword_loc: (7,0)-(7,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/dstr.txt b/test/prism/snapshots/unparser/corpus/semantic/dstr.txt new file mode 100644 index 0000000000..499bf59d1a --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/dstr.txt @@ -0,0 +1,598 @@ +@ ProgramNode (location: (1,0)-(127,11)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(127,11)) + └── body: (length: 33) + ├── @ StringNode (location: (1,0)-(1,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (1,0)-(1,5) = "<<DOC" + │ ├── content_loc: (2,0)-(2,0) = "" + │ ├── closing_loc: (2,0)-(3,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (4,0)-(4,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (4,0)-(4,7) = "<<'DOC'" + │ ├── content_loc: (5,0)-(5,0) = "" + │ ├── closing_loc: (5,0)-(6,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (7,0)-(7,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (7,0)-(7,6) = "<<~DOC" + │ ├── content_loc: (8,0)-(8,0) = "" + │ ├── closing_loc: (8,0)-(9,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (10,0)-(10,8)) + │ ├── flags: ∅ + │ ├── opening_loc: (10,0)-(10,8) = "<<~'DOC'" + │ ├── content_loc: (11,0)-(11,0) = "" + │ ├── closing_loc: (11,0)-(12,0) = "DOC\n" + │ └── unescaped: "" + ├── @ StringNode (location: (13,0)-(13,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (13,0)-(13,5) = "<<DOC" + │ ├── content_loc: (14,0)-(15,0) = " a\n" + │ ├── closing_loc: (15,0)-(16,0) = "DOC\n" + │ └── unescaped: " a\n" + ├── @ StringNode (location: (17,0)-(17,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (17,0)-(17,7) = "<<'DOC'" + │ ├── content_loc: (18,0)-(19,0) = " a\n" + │ ├── closing_loc: (19,0)-(20,0) = "DOC\n" + │ └── unescaped: " a\n" + ├── @ InterpolatedStringNode (location: (21,0)-(21,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (21,0)-(21,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (22,0)-(23,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (22,0)-(23,2) = " a\n " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " a\n " + │ │ ├── @ EmbeddedStatementsNode (location: (23,2)-(23,5)) + │ │ │ ├── opening_loc: (23,2)-(23,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (23,4)-(23,5) = "}" + │ │ └── @ StringNode (location: (23,5)-(24,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (23,5)-(24,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (24,0)-(25,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (26,0)-(26,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (26,0)-(26,6) = "<<~DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (27,0)-(28,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (27,0)-(28,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (28,2)-(28,5)) + │ │ │ ├── opening_loc: (28,2)-(28,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (28,4)-(28,5) = "}" + │ │ └── @ StringNode (location: (28,5)-(29,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (28,5)-(29,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (29,0)-(30,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (31,0)-(31,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (31,0)-(31,6) = "<<~DOC" + │ ├── parts: (length: 4) + │ │ ├── @ StringNode (location: (32,0)-(33,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (32,0)-(33,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (33,2)-(33,5)) + │ │ │ ├── opening_loc: (33,2)-(33,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (33,4)-(33,5) = "}" + │ │ ├── @ StringNode (location: (33,5)-(34,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (33,5)-(34,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── @ StringNode (location: (34,0)-(35,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (34,0)-(35,0) = " b\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b\n" + │ └── closing_loc: (35,0)-(36,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (37,0)-(37,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (37,0)-(37,6) = "<<~DOC" + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (38,0)-(39,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (38,0)-(39,0) = " a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ └── @ StringNode (location: (39,0)-(40,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (39,0)-(40,0) = " b\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: " b\n" + │ └── closing_loc: (40,0)-(41,0) = "DOC\n" + ├── @ StringNode (location: (42,0)-(42,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (42,0)-(42,7) = "<<'DOC'" + │ ├── content_loc: (43,0)-(46,0) = "a\n\nb\n" + │ ├── closing_loc: (46,0)-(47,0) = "DOC\n" + │ └── unescaped: "a\n\nb\n" + ├── @ StringNode (location: (48,0)-(48,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (48,0)-(48,7) = "<<'DOC'" + │ ├── content_loc: (49,0)-(52,0) = " a\n\n b\n" + │ ├── closing_loc: (52,0)-(53,0) = "DOC\n" + │ └── unescaped: " a\n\n b\n" + ├── @ StringNode (location: (54,0)-(54,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (54,0)-(54,7) = "<<'DOC'" + │ ├── content_loc: (55,0)-(56,0) = " a\\nb\n" + │ ├── closing_loc: (56,0)-(57,0) = "DOC\n" + │ └── unescaped: " a\\nb\n" + ├── @ InterpolatedStringNode (location: (58,0)-(58,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (58,0)-(58,5) = "<<DOC" + │ ├── parts: (length: 4) + │ │ ├── @ EmbeddedStatementsNode (location: (59,0)-(59,3)) + │ │ │ ├── opening_loc: (59,0)-(59,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (59,2)-(59,3) = "}" + │ │ ├── @ StringNode (location: (59,3)-(60,1)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (59,3)-(60,1) = "a\n " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n " + │ │ ├── @ EmbeddedStatementsNode (location: (60,1)-(60,4)) + │ │ │ ├── opening_loc: (60,1)-(60,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (60,3)-(60,4) = "}" + │ │ └── @ StringNode (location: (60,4)-(61,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (60,4)-(61,0) = "a\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "a\n" + │ └── closing_loc: (61,0)-(62,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (63,0)-(63,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (63,0)-(63,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (64,0)-(64,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (64,0)-(64,2) = " " + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " " + │ │ ├── @ EmbeddedStatementsNode (location: (64,2)-(64,5)) + │ │ │ ├── opening_loc: (64,2)-(64,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (64,4)-(64,5) = "}" + │ │ └── @ StringNode (location: (64,5)-(66,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (64,5)-(66,0) = "\n \\\#{}\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n \#{}\n" + │ └── closing_loc: (66,0)-(67,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (68,0)-(68,5)) + │ ├── flags: ∅ + │ ├── opening_loc: (68,0)-(68,5) = "<<DOC" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (69,0)-(69,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (69,0)-(69,2) = " a" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: " a" + │ │ ├── @ EmbeddedStatementsNode (location: (69,2)-(69,5)) + │ │ │ ├── opening_loc: (69,2)-(69,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (69,4)-(69,5) = "}" + │ │ └── @ StringNode (location: (69,5)-(71,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (69,5)-(71,0) = "b\n c\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "b\n c\n" + │ └── closing_loc: (71,0)-(72,0) = "DOC\n" + ├── @ InterpolatedStringNode (location: (73,0)-(73,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (73,0)-(73,6) = "<<~DOC" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (74,2)-(74,5)) + │ │ │ ├── opening_loc: (74,2)-(74,4) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (74,4)-(74,5) = "}" + │ │ └── @ StringNode (location: (74,5)-(75,0)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (74,5)-(75,0) = "\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (75,0)-(76,0) = "DOC\n" + ├── @ IfNode (location: (77,0)-(81,3)) + │ ├── if_keyword_loc: (77,0)-(77,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (77,3)-(77,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (78,2)-(78,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (78,2)-(78,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (78,2)-(78,8) = "<<~DOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (79,4)-(79,7)) + │ │ │ │ ├── opening_loc: (79,4)-(79,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (79,6)-(79,7) = "}" + │ │ │ └── @ StringNode (location: (79,7)-(80,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (79,7)-(80,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (80,0)-(81,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (81,0)-(81,3) = "end" + ├── @ IfNode (location: (83,0)-(87,3)) + │ ├── if_keyword_loc: (83,0)-(83,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (83,3)-(83,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (84,2)-(84,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (84,2)-(84,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (84,2)-(84,8) = "<<~DOC" + │ │ ├── parts: (length: 3) + │ │ │ ├── @ StringNode (location: (85,0)-(85,5)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (85,0)-(85,5) = " b" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "b" + │ │ │ ├── @ EmbeddedStatementsNode (location: (85,5)-(85,8)) + │ │ │ │ ├── opening_loc: (85,5)-(85,7) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (85,7)-(85,8) = "}" + │ │ │ └── @ StringNode (location: (85,8)-(86,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (85,8)-(86,0) = "\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n" + │ │ └── closing_loc: (86,0)-(87,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (87,0)-(87,3) = "end" + ├── @ IfNode (location: (89,0)-(93,3)) + │ ├── if_keyword_loc: (89,0)-(89,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (89,3)-(89,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (90,2)-(90,8)) + │ │ └── body: (length: 1) + │ │ └── @ InterpolatedStringNode (location: (90,2)-(90,8)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (90,2)-(90,8) = "<<~DOC" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ EmbeddedStatementsNode (location: (91,4)-(91,7)) + │ │ │ │ ├── opening_loc: (91,4)-(91,6) = "\#{" + │ │ │ │ ├── statements: ∅ + │ │ │ │ └── closing_loc: (91,6)-(91,7) = "}" + │ │ │ └── @ StringNode (location: (91,7)-(92,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (91,7)-(92,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ └── closing_loc: (92,0)-(93,0) = " DOC\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (93,0)-(93,3) = "end" + ├── @ IfNode (location: (95,0)-(101,3)) + │ ├── if_keyword_loc: (95,0)-(95,2) = "if" + │ ├── predicate: + │ │ @ TrueNode (location: (95,3)-(95,7)) + │ ├── then_keyword_loc: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (96,2)-(96,10)) + │ │ └── body: (length: 1) + │ │ └── @ StringNode (location: (96,2)-(96,10)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (96,2)-(96,10) = "<<-'DOC'" + │ │ ├── content_loc: (97,0)-(100,0) = " a\n\n b\n" + │ │ ├── closing_loc: (100,0)-(101,0) = " DOC\n" + │ │ └── unescaped: " a\n\n b\n" + │ ├── consequent: ∅ + │ └── end_keyword_loc: (101,0)-(101,3) = "end" + ├── @ InterpolatedStringNode (location: (103,0)-(103,6)) + │ ├── flags: ∅ + │ ├── opening_loc: (103,0)-(103,1) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (103,1)-(103,4)) + │ │ │ ├── opening_loc: (103,1)-(103,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (103,3)-(103,4) = "}" + │ │ └── @ StringNode (location: (103,4)-(103,5)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (103,4)-(103,5) = "a" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "a" + │ └── closing_loc: (103,5)-(103,6) = "\"" + ├── @ InterpolatedStringNode (location: (105,0)-(105,12)) + │ ├── flags: ∅ + │ ├── opening_loc: (105,0)-(105,2) = "%(" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (105,2)-(105,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (105,2)-(105,5) = "\\n\"" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "\n\"" + │ │ ├── @ EmbeddedStatementsNode (location: (105,5)-(105,8)) + │ │ │ ├── opening_loc: (105,5)-(105,7) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (105,7)-(105,8) = "}" + │ │ └── @ StringNode (location: (105,8)-(105,11)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (105,8)-(105,11) = "\"\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\"\n" + │ └── closing_loc: (105,11)-(105,12) = ")" + ├── @ InterpolatedStringNode (location: (107,0)-(107,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (107,0)-(107,3) = "%Q(" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (107,3)-(107,7)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (107,3)-(107,7) = "-\\n\"" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "-\n\"" + │ │ ├── @ EmbeddedStatementsNode (location: (107,7)-(107,10)) + │ │ │ ├── opening_loc: (107,7)-(107,9) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (107,9)-(107,10) = "}" + │ │ └── @ StringNode (location: (107,10)-(107,13)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (107,10)-(107,13) = "\"\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\"\n" + │ └── closing_loc: (107,13)-(107,14) = ")" + ├── @ InterpolatedStringNode (location: (109,0)-(111,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (109,0)-(109,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (109,1)-(110,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (109,1)-(110,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (110,0)-(110,3)) + │ │ │ ├── opening_loc: (110,0)-(110,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (110,2)-(110,3) = "}" + │ │ └── @ StringNode (location: (110,3)-(111,1)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (110,3)-(111,1) = "\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (111,1)-(111,2) = "\"" + ├── @ InterpolatedStringNode (location: (113,0)-(114,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (113,0)-(113,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (113,1)-(113,4)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (113,1)-(113,4) = "a\\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (113,4)-(113,7)) + │ │ │ ├── opening_loc: (113,4)-(113,6) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (113,6)-(113,7) = "}" + │ │ └── @ StringNode (location: (113,7)-(114,1)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (113,7)-(114,1) = "\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (114,1)-(114,2) = "\"" + ├── @ InterpolatedStringNode (location: (116,0)-(117,7)) + │ ├── flags: ∅ + │ ├── opening_loc: (116,0)-(116,1) = "\"" + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (116,1)-(117,0)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── content_loc: (116,1)-(117,0) = "a\n" + │ │ │ ├── closing_loc: ∅ + │ │ │ └── unescaped: "a\n" + │ │ ├── @ EmbeddedStatementsNode (location: (117,0)-(117,3)) + │ │ │ ├── opening_loc: (117,0)-(117,2) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (117,2)-(117,3) = "}" + │ │ └── @ StringNode (location: (117,3)-(117,6)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (117,3)-(117,6) = "\\nb" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\nb" + │ └── closing_loc: (117,6)-(117,7) = "\"" + ├── @ InterpolatedStringNode (location: (119,0)-(120,5)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ StringNode (location: (119,0)-(119,3)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (119,0)-(119,1) = "'" + │ │ │ ├── content_loc: (119,1)-(119,2) = "a" + │ │ │ ├── closing_loc: (119,2)-(119,3) = "'" + │ │ │ └── unescaped: "a" + │ │ └── @ InterpolatedStringNode (location: (120,0)-(120,5)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (120,0)-(120,1) = "\"" + │ │ ├── parts: (length: 1) + │ │ │ └── @ EmbeddedStatementsNode (location: (120,1)-(120,4)) + │ │ │ ├── opening_loc: (120,1)-(120,3) = "\#{" + │ │ │ ├── statements: ∅ + │ │ │ └── closing_loc: (120,3)-(120,4) = "}" + │ │ └── closing_loc: (120,4)-(120,5) = "\"" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (122,0)-(122,8)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 3) + │ │ ├── @ StringNode (location: (122,0)-(122,2)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (122,0)-(122,1) = "\"" + │ │ │ ├── content_loc: (122,1)-(122,1) = "" + │ │ │ ├── closing_loc: (122,1)-(122,2) = "\"" + │ │ │ └── unescaped: "" + │ │ ├── @ StringNode (location: (122,3)-(122,5)) + │ │ │ ├── flags: frozen + │ │ │ ├── opening_loc: (122,3)-(122,4) = "\"" + │ │ │ ├── content_loc: (122,4)-(122,4) = "" + │ │ │ ├── closing_loc: (122,4)-(122,5) = "\"" + │ │ │ └── unescaped: "" + │ │ └── @ StringNode (location: (122,6)-(122,8)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (122,6)-(122,7) = "\"" + │ │ ├── content_loc: (122,7)-(122,7) = "" + │ │ ├── closing_loc: (122,7)-(122,8) = "\"" + │ │ └── unescaped: "" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (124,0)-(124,12)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (124,0)-(124,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (124,0)-(124,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (124,1)-(124,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (124,1)-(124,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedStatementsNode (location: (124,2)-(124,7)) + │ │ │ │ ├── opening_loc: (124,2)-(124,4) = "\#{" + │ │ │ │ ├── statements: + │ │ │ │ │ @ StatementsNode (location: (124,4)-(124,6)) + │ │ │ │ │ └── body: (length: 1) + │ │ │ │ │ └── @ InstanceVariableReadNode (location: (124,4)-(124,6)) + │ │ │ │ │ └── name: :@a + │ │ │ │ └── closing_loc: (124,6)-(124,7) = "}" + │ │ │ └── closing_loc: (124,7)-(124,8) = "\"" + │ │ └── @ StringNode (location: (124,9)-(124,12)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (124,9)-(124,10) = "\"" + │ │ ├── content_loc: (124,10)-(124,11) = "b" + │ │ ├── closing_loc: (124,11)-(124,12) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (125,0)-(125,10)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (125,0)-(125,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (125,0)-(125,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (125,1)-(125,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (125,1)-(125,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedVariableNode (location: (125,2)-(125,5)) + │ │ │ │ ├── operator_loc: (125,2)-(125,3) = "#" + │ │ │ │ └── variable: + │ │ │ │ @ InstanceVariableReadNode (location: (125,3)-(125,5)) + │ │ │ │ └── name: :@a + │ │ │ └── closing_loc: (125,5)-(125,6) = "\"" + │ │ └── @ StringNode (location: (125,7)-(125,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (125,7)-(125,8) = "\"" + │ │ ├── content_loc: (125,8)-(125,9) = "b" + │ │ ├── closing_loc: (125,9)-(125,10) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + ├── @ InterpolatedStringNode (location: (126,0)-(126,10)) + │ ├── flags: ∅ + │ ├── opening_loc: ∅ + │ ├── parts: (length: 2) + │ │ ├── @ InterpolatedStringNode (location: (126,0)-(126,6)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (126,0)-(126,1) = "\"" + │ │ │ ├── parts: (length: 2) + │ │ │ │ ├── @ StringNode (location: (126,1)-(126,2)) + │ │ │ │ │ ├── flags: frozen + │ │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ │ ├── content_loc: (126,1)-(126,2) = "a" + │ │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ │ └── unescaped: "a" + │ │ │ │ └── @ EmbeddedVariableNode (location: (126,2)-(126,5)) + │ │ │ │ ├── operator_loc: (126,2)-(126,3) = "#" + │ │ │ │ └── variable: + │ │ │ │ @ GlobalVariableReadNode (location: (126,3)-(126,5)) + │ │ │ │ └── name: :$a + │ │ │ └── closing_loc: (126,5)-(126,6) = "\"" + │ │ └── @ StringNode (location: (126,7)-(126,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: (126,7)-(126,8) = "\"" + │ │ ├── content_loc: (126,8)-(126,9) = "b" + │ │ ├── closing_loc: (126,9)-(126,10) = "\"" + │ │ └── unescaped: "b" + │ └── closing_loc: ∅ + └── @ InterpolatedStringNode (location: (127,0)-(127,11)) + ├── flags: ∅ + ├── opening_loc: ∅ + ├── parts: (length: 2) + │ ├── @ InterpolatedStringNode (location: (127,0)-(127,7)) + │ │ ├── flags: ∅ + │ │ ├── opening_loc: (127,0)-(127,1) = "\"" + │ │ ├── parts: (length: 2) + │ │ │ ├── @ StringNode (location: (127,1)-(127,2)) + │ │ │ │ ├── flags: frozen + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── content_loc: (127,1)-(127,2) = "a" + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── unescaped: "a" + │ │ │ └── @ EmbeddedVariableNode (location: (127,2)-(127,6)) + │ │ │ ├── operator_loc: (127,2)-(127,3) = "#" + │ │ │ └── variable: + │ │ │ @ ClassVariableReadNode (location: (127,3)-(127,6)) + │ │ │ └── name: :@@a + │ │ └── closing_loc: (127,6)-(127,7) = "\"" + │ └── @ StringNode (location: (127,8)-(127,11)) + │ ├── flags: frozen + │ ├── opening_loc: (127,8)-(127,9) = "\"" + │ ├── content_loc: (127,9)-(127,10) = "b" + │ ├── closing_loc: (127,10)-(127,11) = "\"" + │ └── unescaped: "b" + └── closing_loc: ∅ diff --git a/test/prism/snapshots/unparser/corpus/semantic/kwbegin.txt b/test/prism/snapshots/unparser/corpus/semantic/kwbegin.txt new file mode 100644 index 0000000000..38486ddc12 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/kwbegin.txt @@ -0,0 +1,259 @@ +@ ProgramNode (location: (1,0)-(42,3)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(42,3)) + └── body: (length: 8) + ├── @ BeginNode (location: (1,0)-(3,3)) + │ ├── begin_keyword_loc: (1,0)-(1,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (2,0)-(2,6)) + │ │ ├── keyword_loc: (2,0)-(2,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (3,0)-(3,3) = "end" + ├── @ BeginNode (location: (5,0)-(8,3)) + │ ├── begin_keyword_loc: (5,0)-(5,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (6,0)-(6,6)) + │ │ ├── keyword_loc: (6,0)-(6,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: + │ │ @ ElseNode (location: (7,0)-(8,3)) + │ │ ├── else_keyword_loc: (7,0)-(7,4) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (8,0)-(8,3) = "end" + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (8,0)-(8,3) = "end" + ├── @ BeginNode (location: (10,0)-(12,3)) + │ ├── begin_keyword_loc: (10,0)-(10,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (11,2)-(11,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (11,2)-(11,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (11,2)-(11,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (12,0)-(12,3) = "end" + ├── @ BeginNode (location: (14,0)-(18,3)) + │ ├── begin_keyword_loc: (14,0)-(14,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (15,2)-(15,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (15,2)-(15,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :a + │ │ ├── message_loc: (15,2)-(15,3) = "a" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (16,0)-(17,3)) + │ │ ├── keyword_loc: (16,0)-(16,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (17,2)-(17,3)) + │ │ │ └── body: (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: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (18,0)-(18,3) = "end" + ├── @ BeginNode (location: (20,0)-(25,3)) + │ ├── begin_keyword_loc: (20,0)-(20,5) = "begin" + │ ├── statements: + │ │ @ StatementsNode (location: (21,2)-(22,3)) + │ │ └── body: (length: 2) + │ │ ├── @ CallNode (location: (21,2)-(21,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (21,2)-(21,3) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── @ 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: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (23,0)-(24,3)) + │ │ ├── keyword_loc: (23,0)-(23,6) = "rescue" + │ │ ├── exceptions: (length: 0) + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (24,2)-(24,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (24,2)-(24,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (24,2)-(24,3) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: ∅ + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (25,0)-(25,3) = "end" + ├── @ BeginNode (location: (27,0)-(30,3)) + │ ├── begin_keyword_loc: (27,0)-(27,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (28,0)-(28,8)) + │ │ ├── keyword_loc: (28,0)-(28,6) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (28,7)-(28,8)) + │ │ │ └── name: :A + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: + │ │ @ ElseNode (location: (29,0)-(30,3)) + │ │ ├── else_keyword_loc: (29,0)-(29,4) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (30,0)-(30,3) = "end" + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (30,0)-(30,3) = "end" + ├── @ BeginNode (location: (32,0)-(32,26)) + │ ├── begin_keyword_loc: (32,0)-(32,5) = "begin" + │ ├── statements: ∅ + │ ├── rescue_clause: + │ │ @ RescueNode (location: (32,7)-(32,15)) + │ │ ├── keyword_loc: (32,7)-(32,13) = "rescue" + │ │ ├── exceptions: (length: 1) + │ │ │ └── @ ConstantReadNode (location: (32,14)-(32,15)) + │ │ │ └── name: :A + │ │ ├── operator_loc: ∅ + │ │ ├── reference: ∅ + │ │ ├── statements: ∅ + │ │ └── consequent: ∅ + │ ├── else_clause: + │ │ @ ElseNode (location: (32,17)-(32,26)) + │ │ ├── else_keyword_loc: (32,17)-(32,21) = "else" + │ │ ├── statements: ∅ + │ │ └── end_keyword_loc: (32,23)-(32,26) = "end" + │ ├── ensure_clause: ∅ + │ └── end_keyword_loc: (32,23)-(32,26) = "end" + └── @ BeginNode (location: (34,0)-(42,3)) + ├── begin_keyword_loc: (34,0)-(34,5) = "begin" + ├── statements: + │ @ StatementsNode (location: (35,2)-(35,3)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (35,2)-(35,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (35,2)-(35,3) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── rescue_clause: + │ @ RescueNode (location: (36,0)-(39,3)) + │ ├── keyword_loc: (36,0)-(36,6) = "rescue" + │ ├── exceptions: (length: 1) + │ │ └── @ ConstantReadNode (location: (36,7)-(36,8)) + │ │ └── name: :A + │ ├── operator_loc: ∅ + │ ├── reference: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (37,2)-(37,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (37,2)-(37,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (37,2)-(37,3) = "b" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── consequent: + │ @ RescueNode (location: (38,0)-(39,3)) + │ ├── keyword_loc: (38,0)-(38,6) = "rescue" + │ ├── exceptions: (length: 1) + │ │ └── @ ConstantReadNode (location: (38,7)-(38,8)) + │ │ └── name: :B + │ ├── operator_loc: ∅ + │ ├── reference: ∅ + │ ├── statements: + │ │ @ StatementsNode (location: (39,2)-(39,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (39,2)-(39,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (39,2)-(39,3) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── consequent: ∅ + ├── else_clause: ∅ + ├── ensure_clause: + │ @ EnsureNode (location: (40,0)-(42,3)) + │ ├── ensure_keyword_loc: (40,0)-(40,6) = "ensure" + │ ├── statements: + │ │ @ StatementsNode (location: (41,2)-(41,3)) + │ │ └── body: (length: 1) + │ │ └── @ CallNode (location: (41,2)-(41,3)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (41,2)-(41,3) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── end_keyword_loc: (42,0)-(42,3) = "end" + └── end_keyword_loc: (42,0)-(42,3) = "end" diff --git a/test/prism/snapshots/unparser/corpus/semantic/literal.txt b/test/prism/snapshots/unparser/corpus/semantic/literal.txt new file mode 100644 index 0000000000..ef666890be --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/literal.txt @@ -0,0 +1,103 @@ +@ ProgramNode (location: (1,0)-(14,10)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(14,10)) + └── body: (length: 14) + ├── @ RationalNode (location: (1,0)-(1,4)) + │ └── numeric: + │ @ FloatNode (location: (1,0)-(1,3)) + │ └── value: 1.0 + ├── @ RationalNode (location: (2,0)-(2,3)) + │ └── numeric: + │ @ IntegerNode (location: (2,0)-(2,2)) + │ ├── flags: decimal + │ └── value: 0 + ├── @ IntegerNode (location: (3,0)-(3,3)) + │ ├── flags: hexadecimal + │ └── value: 1 + ├── @ IntegerNode (location: (4,0)-(4,5)) + │ ├── flags: decimal + │ └── value: 1000 + ├── @ FloatNode (location: (5,0)-(5,4)) + │ └── value: 10000000000.0 + ├── @ FloatNode (location: (6,0)-(6,14)) + │ └── value: Infinity + ├── @ FloatNode (location: (7,0)-(7,15)) + │ └── value: -Infinity + ├── @ StringNode (location: (8,0)-(8,2)) + │ ├── flags: ∅ + │ ├── opening_loc: (8,0)-(8,1) = "?" + │ ├── content_loc: (8,1)-(8,2) = "c" + │ ├── closing_loc: ∅ + │ └── unescaped: "c" + ├── @ RegularExpressionNode (location: (9,0)-(9,5)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (9,0)-(9,3) = "%r(" + │ ├── content_loc: (9,3)-(9,4) = "/" + │ ├── closing_loc: (9,4)-(9,5) = ")" + │ └── unescaped: "/" + ├── @ RegularExpressionNode (location: (10,0)-(10,6)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: (10,0)-(10,3) = "%r(" + │ ├── content_loc: (10,3)-(10,5) = "\\)" + │ ├── closing_loc: (10,5)-(10,6) = ")" + │ └── unescaped: "\\)" + ├── @ InterpolatedRegularExpressionNode (location: (11,0)-(11,14)) + │ ├── flags: ∅ + │ ├── opening_loc: (11,0)-(11,3) = "%r(" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (11,3)-(11,10)) + │ │ │ ├── opening_loc: (11,3)-(11,5) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (11,5)-(11,9)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ InstanceVariableReadNode (location: (11,5)-(11,9)) + │ │ │ │ └── name: :@bar + │ │ │ └── closing_loc: (11,9)-(11,10) = "}" + │ │ └── @ StringNode (location: (11,10)-(11,13)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (11,10)-(11,13) = "baz" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "baz" + │ └── closing_loc: (11,13)-(11,14) = ")" + ├── @ FloatNode (location: (12,0)-(12,16)) + │ └── value: Infinity + ├── @ FloatNode (location: (13,0)-(13,17)) + │ └── value: -Infinity + └── @ CallNode (location: (14,0)-(14,10)) + ├── flags: ignore_visibility + ├── receiver: ∅ + ├── call_operator_loc: ∅ + ├── name: :w + ├── message_loc: (14,0)-(14,1) = "w" + ├── opening_loc: (14,1)-(14,2) = "(" + ├── arguments: + │ @ ArgumentsNode (location: (14,2)-(14,9)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ CallNode (location: (14,2)-(14,9)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (14,2)-(14,5) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (14,6)-(14,9)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (14,6)-(14,9)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (14,6)-(14,9) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── closing_loc: (14,9)-(14,10) = ")" + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/semantic/opasgn.txt b/test/prism/snapshots/unparser/corpus/semantic/opasgn.txt new file mode 100644 index 0000000000..7dd26a38dc --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/opasgn.txt @@ -0,0 +1,69 @@ +@ ProgramNode (location: (1,0)-(1,25)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(1,25)) + └── body: (length: 1) + └── @ IndexOperatorWriteNode (location: (1,0)-(1,25)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (1,0)-(1,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :y + │ ├── message_loc: (1,0)-(1,1) = "y" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: ∅ + ├── opening_loc: (1,1)-(1,2) = "[" + ├── arguments: + │ @ ArgumentsNode (location: (1,2)-(1,11)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ InterpolatedStringNode (location: (1,2)-(1,11)) + │ ├── flags: ∅ + │ ├── opening_loc: (1,2)-(1,3) = "\"" + │ ├── parts: (length: 2) + │ │ ├── @ EmbeddedStatementsNode (location: (1,3)-(1,8)) + │ │ │ ├── opening_loc: (1,3)-(1,5) = "\#{" + │ │ │ ├── statements: + │ │ │ │ @ StatementsNode (location: (1,5)-(1,7)) + │ │ │ │ └── body: (length: 1) + │ │ │ │ └── @ IntegerNode (location: (1,5)-(1,7)) + │ │ │ │ ├── flags: decimal + │ │ │ │ └── value: 42 + │ │ │ └── closing_loc: (1,7)-(1,8) = "}" + │ │ └── @ StringNode (location: (1,8)-(1,10)) + │ │ ├── flags: frozen + │ │ ├── opening_loc: ∅ + │ │ ├── content_loc: (1,8)-(1,10) = "\\n" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "\n" + │ └── closing_loc: (1,10)-(1,11) = "\"" + ├── closing_loc: (1,11)-(1,12) = "]" + ├── block: ∅ + ├── binary_operator: :+ + ├── binary_operator_loc: (1,13)-(1,15) = "+=" + └── value: + @ InterpolatedStringNode (location: (1,16)-(1,25)) + ├── flags: ∅ + ├── opening_loc: (1,16)-(1,17) = "\"" + ├── parts: (length: 2) + │ ├── @ EmbeddedStatementsNode (location: (1,17)-(1,22)) + │ │ ├── opening_loc: (1,17)-(1,19) = "\#{" + │ │ ├── statements: + │ │ │ @ StatementsNode (location: (1,19)-(1,21)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ IntegerNode (location: (1,19)-(1,21)) + │ │ │ ├── flags: decimal + │ │ │ └── value: 42 + │ │ └── closing_loc: (1,21)-(1,22) = "}" + │ └── @ StringNode (location: (1,22)-(1,24)) + │ ├── flags: frozen + │ ├── opening_loc: ∅ + │ ├── content_loc: (1,22)-(1,24) = "\\n" + │ ├── closing_loc: ∅ + │ └── unescaped: "\n" + └── closing_loc: (1,24)-(1,25) = "\"" diff --git a/test/prism/snapshots/unparser/corpus/semantic/send.txt b/test/prism/snapshots/unparser/corpus/semantic/send.txt new file mode 100644 index 0000000000..7c152c3bfb --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/send.txt @@ -0,0 +1,163 @@ +@ ProgramNode (location: (1,0)-(6,15)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(6,15)) + └── body: (length: 4) + ├── @ CallNode (location: (1,0)-(1,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (1,0)-(1,3) = "foo" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ CallNode (location: (2,0)-(2,6)) + │ ├── flags: ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :foo + │ ├── message_loc: (2,0)-(2,3) = "foo" + │ ├── opening_loc: (2,3)-(2,4) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (2,4)-(2,5)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ IntegerNode (location: (2,4)-(2,5)) + │ │ ├── flags: decimal + │ │ └── value: 1 + │ ├── closing_loc: (2,5)-(2,6) = ")" + │ └── block: ∅ + ├── @ CallNode (location: (4,0)-(4,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (4,0)-(4,10)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (4,0)-(4,8)) + │ │ │ ├── flags: ∅ + │ │ │ ├── receiver: + │ │ │ │ @ CallNode (location: (4,0)-(4,1)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :a + │ │ │ │ ├── message_loc: (4,0)-(4,1) = "a" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── call_operator_loc: (4,1)-(4,2) = "." + │ │ │ ├── name: :=== + │ │ │ ├── message_loc: (4,2)-(4,5) = "===" + │ │ │ ├── opening_loc: (4,5)-(4,6) = "(" + │ │ │ ├── arguments: + │ │ │ │ @ ArgumentsNode (location: (4,6)-(4,7)) + │ │ │ │ ├── flags: ∅ + │ │ │ │ └── arguments: (length: 1) + │ │ │ │ └── @ CallNode (location: (4,6)-(4,7)) + │ │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ │ ├── receiver: ∅ + │ │ │ │ ├── call_operator_loc: ∅ + │ │ │ │ ├── name: :b + │ │ │ │ ├── message_loc: (4,6)-(4,7) = "b" + │ │ │ │ ├── opening_loc: ∅ + │ │ │ │ ├── arguments: ∅ + │ │ │ │ ├── closing_loc: ∅ + │ │ │ │ └── block: ∅ + │ │ │ ├── closing_loc: (4,7)-(4,8) = ")" + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (4,8)-(4,9) = "." + │ │ ├── name: :c + │ │ ├── message_loc: (4,9)-(4,10) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :== + │ ├── message_loc: (4,11)-(4,13) = "==" + │ ├── opening_loc: ∅ + │ ├── arguments: + │ │ @ ArgumentsNode (location: (4,14)-(4,15)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (4,14)-(4,15)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :d + │ │ ├── message_loc: (4,14)-(4,15) = "d" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + └── @ CallNode (location: (6,0)-(6,15)) + ├── flags: ∅ + ├── receiver: + │ @ CallNode (location: (6,0)-(6,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (6,0)-(6,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── call_operator_loc: ∅ + ├── name: :== + ├── message_loc: (6,2)-(6,4) = "==" + ├── opening_loc: ∅ + ├── arguments: + │ @ ArgumentsNode (location: (6,5)-(6,15)) + │ ├── flags: ∅ + │ └── arguments: (length: 1) + │ └── @ CallNode (location: (6,5)-(6,15)) + │ ├── flags: ∅ + │ ├── receiver: + │ │ @ CallNode (location: (6,5)-(6,8)) + │ │ ├── flags: ∅ + │ │ ├── receiver: + │ │ │ @ CallNode (location: (6,5)-(6,6)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :d + │ │ │ ├── message_loc: (6,5)-(6,6) = "d" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── call_operator_loc: (6,6)-(6,7) = "." + │ │ ├── name: :c + │ │ ├── message_loc: (6,7)-(6,8) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── call_operator_loc: (6,8)-(6,9) = "." + │ ├── name: :=== + │ ├── message_loc: (6,9)-(6,12) = "===" + │ ├── opening_loc: (6,12)-(6,13) = "(" + │ ├── arguments: + │ │ @ ArgumentsNode (location: (6,13)-(6,14)) + │ │ ├── flags: ∅ + │ │ └── arguments: (length: 1) + │ │ └── @ CallNode (location: (6,13)-(6,14)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :c + │ │ ├── message_loc: (6,13)-(6,14) = "c" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ ├── closing_loc: (6,14)-(6,15) = ")" + │ └── block: ∅ + ├── closing_loc: ∅ + └── block: ∅ diff --git a/test/prism/snapshots/unparser/corpus/semantic/undef.txt b/test/prism/snapshots/unparser/corpus/semantic/undef.txt new file mode 100644 index 0000000000..ecb073148d --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/undef.txt @@ -0,0 +1,29 @@ +@ ProgramNode (location: (1,0)-(2,14)) +├── locals: [] +└── statements: + @ StatementsNode (location: (1,0)-(2,14)) + └── body: (length: 2) + ├── @ UndefNode (location: (1,0)-(1,9)) + │ ├── names: (length: 1) + │ │ └── @ SymbolNode (location: (1,6)-(1,9)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (1,6)-(1,9) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ └── keyword_loc: (1,0)-(1,5) = "undef" + └── @ UndefNode (location: (2,0)-(2,14)) + ├── names: (length: 2) + │ ├── @ SymbolNode (location: (2,6)-(2,9)) + │ │ ├── flags: forced_us_ascii_encoding + │ │ ├── opening_loc: ∅ + │ │ ├── value_loc: (2,6)-(2,9) = "foo" + │ │ ├── closing_loc: ∅ + │ │ └── unescaped: "foo" + │ └── @ SymbolNode (location: (2,11)-(2,14)) + │ ├── flags: forced_us_ascii_encoding + │ ├── opening_loc: ∅ + │ ├── value_loc: (2,11)-(2,14) = "bar" + │ ├── closing_loc: ∅ + │ └── unescaped: "bar" + └── keyword_loc: (2,0)-(2,5) = "undef" diff --git a/test/prism/snapshots/unparser/corpus/semantic/while.txt b/test/prism/snapshots/unparser/corpus/semantic/while.txt new file mode 100644 index 0000000000..36bfba5be6 --- /dev/null +++ b/test/prism/snapshots/unparser/corpus/semantic/while.txt @@ -0,0 +1,277 @@ +@ ProgramNode (location: (1,0)-(25,3)) +├── locals: [:foo, :a] +└── statements: + @ StatementsNode (location: (1,0)-(25,3)) + └── body: (length: 7) + ├── @ UntilNode (location: (1,0)-(1,13)) + │ ├── flags: ∅ + │ ├── keyword_loc: (1,2)-(1,7) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (1,8)-(1,13)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b? + │ │ ├── message_loc: (1,8)-(1,10) = "b?" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (1,11)-(1,13)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (1,11)-(1,12) = "{" + │ │ └── closing_loc: (1,12)-(1,13) = "}" + │ └── statements: + │ @ StatementsNode (location: (1,0)-(1,1)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (1,0)-(1,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (1,0)-(1,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ UntilNode (location: (3,0)-(5,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (3,0)-(3,5) = "until" + │ ├── closing_loc: (5,0)-(5,3) = "end" + │ ├── predicate: + │ │ @ CallNode (location: (3,6)-(3,11)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b? + │ │ ├── message_loc: (3,6)-(3,8) = "b?" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: + │ │ @ BlockNode (location: (3,9)-(3,11)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: ∅ + │ │ ├── opening_loc: (3,9)-(3,10) = "{" + │ │ └── closing_loc: (3,10)-(3,11) = "}" + │ └── statements: + │ @ StatementsNode (location: (4,2)-(4,3)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (4,2)-(4,3)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (4,2)-(4,3) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ WhileNode (location: (7,0)-(7,19)) + │ ├── flags: ∅ + │ ├── keyword_loc: (7,10)-(7,15) = "while" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ LocalVariableReadNode (location: (7,16)-(7,19)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ └── statements: + │ @ StatementsNode (location: (7,0)-(7,9)) + │ └── body: (length: 1) + │ └── @ LocalVariableWriteNode (location: (7,0)-(7,9)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (7,0)-(7,3) = "foo" + │ ├── value: + │ │ @ CallNode (location: (7,6)-(7,9)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (7,6)-(7,9) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (7,4)-(7,5) = "=" + ├── @ UntilNode (location: (9,0)-(9,18)) + │ ├── flags: ∅ + │ ├── keyword_loc: (9,2)-(9,7) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ AndNode (location: (9,8)-(9,18)) + │ │ ├── left: + │ │ │ @ CallNode (location: (9,8)-(9,9)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (9,8)-(9,9) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── right: + │ │ │ @ CallNode (location: (9,13)-(9,18)) + │ │ │ ├── flags: ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :a + │ │ │ ├── message_loc: (9,13)-(9,14) = "a" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: + │ │ │ @ BlockNode (location: (9,15)-(9,18)) + │ │ │ ├── locals: [] + │ │ │ ├── parameters: ∅ + │ │ │ ├── body: ∅ + │ │ │ ├── opening_loc: (9,15)-(9,16) = "{" + │ │ │ └── closing_loc: (9,17)-(9,18) = "}" + │ │ └── operator_loc: (9,10)-(9,12) = "&&" + │ └── statements: + │ @ StatementsNode (location: (9,0)-(9,1)) + │ └── body: (length: 1) + │ └── @ CallNode (location: (9,0)-(9,1)) + │ ├── flags: variable_call, ignore_visibility + │ ├── receiver: ∅ + │ ├── call_operator_loc: ∅ + │ ├── name: :a + │ ├── message_loc: (9,0)-(9,1) = "a" + │ ├── opening_loc: ∅ + │ ├── arguments: ∅ + │ ├── closing_loc: ∅ + │ └── block: ∅ + ├── @ WhileNode (location: (11,0)-(13,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (11,0)-(11,5) = "while" + │ ├── closing_loc: (13,0)-(13,3) = "end" + │ ├── predicate: + │ │ @ LocalVariableWriteNode (location: (11,6)-(11,11)) + │ │ ├── name: :a + │ │ ├── depth: 0 + │ │ ├── name_loc: (11,6)-(11,7) = "a" + │ │ ├── value: + │ │ │ @ CallNode (location: (11,10)-(11,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :b + │ │ │ ├── message_loc: (11,10)-(11,11) = "b" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (11,8)-(11,9) = "=" + │ └── statements: + │ @ StatementsNode (location: (12,2)-(12,3)) + │ └── body: (length: 1) + │ └── @ LocalVariableReadNode (location: (12,2)-(12,3)) + │ ├── name: :a + │ └── depth: 0 + ├── @ UntilNode (location: (15,0)-(18,3)) + │ ├── flags: ∅ + │ ├── keyword_loc: (15,2)-(15,7) = "until" + │ ├── closing_loc: ∅ + │ ├── predicate: + │ │ @ CallNode (location: (15,8)-(18,3)) + │ │ ├── flags: ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :b + │ │ ├── message_loc: (15,8)-(15,9) = "b" + │ │ ├── opening_loc: (15,9)-(15,10) = "(" + │ │ ├── arguments: + │ │ │ @ ArgumentsNode (location: (15,10)-(15,16)) + │ │ │ ├── flags: ∅ + │ │ │ └── arguments: (length: 1) + │ │ │ └── @ StringNode (location: (15,10)-(15,16)) + │ │ │ ├── flags: ∅ + │ │ │ ├── opening_loc: (15,10)-(15,16) = "<<-FOO" + │ │ │ ├── content_loc: (16,0)-(16,0) = "" + │ │ │ ├── closing_loc: (16,0)-(17,0) = "FOO\n" + │ │ │ └── unescaped: "" + │ │ ├── closing_loc: (15,16)-(15,17) = ")" + │ │ └── block: + │ │ @ BlockNode (location: (15,18)-(18,3)) + │ │ ├── locals: [] + │ │ ├── parameters: ∅ + │ │ ├── body: + │ │ │ @ StatementsNode (location: (17,2)-(17,3)) + │ │ │ └── body: (length: 1) + │ │ │ └── @ CallNode (location: (17,2)-(17,3)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :c + │ │ │ ├── message_loc: (17,2)-(17,3) = "c" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ ├── opening_loc: (15,18)-(15,20) = "do" + │ │ └── closing_loc: (18,0)-(18,3) = "end" + │ └── statements: + │ @ StatementsNode (location: (15,0)-(15,1)) + │ └── body: (length: 1) + │ └── @ LocalVariableReadNode (location: (15,0)-(15,1)) + │ ├── name: :a + │ └── depth: 0 + └── @ ModuleNode (location: (20,0)-(25,3)) + ├── locals: [:foo] + ├── module_keyword_loc: (20,0)-(20,6) = "module" + ├── constant_path: + │ @ ConstantReadNode (location: (20,7)-(20,8)) + │ └── name: :A + ├── body: + │ @ StatementsNode (location: (21,2)-(24,5)) + │ └── body: (length: 2) + │ ├── @ LocalVariableWriteNode (location: (21,2)-(21,11)) + │ │ ├── name: :foo + │ │ ├── depth: 0 + │ │ ├── name_loc: (21,2)-(21,5) = "foo" + │ │ ├── value: + │ │ │ @ CallNode (location: (21,8)-(21,11)) + │ │ │ ├── flags: variable_call, ignore_visibility + │ │ │ ├── receiver: ∅ + │ │ │ ├── call_operator_loc: ∅ + │ │ │ ├── name: :exp + │ │ │ ├── message_loc: (21,8)-(21,11) = "exp" + │ │ │ ├── opening_loc: ∅ + │ │ │ ├── arguments: ∅ + │ │ │ ├── closing_loc: ∅ + │ │ │ └── block: ∅ + │ │ └── operator_loc: (21,6)-(21,7) = "=" + │ └── @ WhileNode (location: (22,2)-(24,5)) + │ ├── flags: ∅ + │ ├── keyword_loc: (22,2)-(22,7) = "while" + │ ├── closing_loc: (24,2)-(24,5) = "end" + │ ├── predicate: + │ │ @ LocalVariableReadNode (location: (22,8)-(22,11)) + │ │ ├── name: :foo + │ │ └── depth: 0 + │ └── statements: + │ @ StatementsNode (location: (23,4)-(23,13)) + │ └── body: (length: 1) + │ └── @ LocalVariableWriteNode (location: (23,4)-(23,13)) + │ ├── name: :foo + │ ├── depth: 0 + │ ├── name_loc: (23,4)-(23,7) = "foo" + │ ├── value: + │ │ @ CallNode (location: (23,10)-(23,13)) + │ │ ├── flags: variable_call, ignore_visibility + │ │ ├── receiver: ∅ + │ │ ├── call_operator_loc: ∅ + │ │ ├── name: :bar + │ │ ├── message_loc: (23,10)-(23,13) = "bar" + │ │ ├── opening_loc: ∅ + │ │ ├── arguments: ∅ + │ │ ├── closing_loc: ∅ + │ │ └── block: ∅ + │ └── operator_loc: (23,8)-(23,9) = "=" + ├── end_keyword_loc: (25,0)-(25,3) = "end" + └── name: :A |