@ ProgramNode (location: (1,0)-(41,10))
├── flags: ∅
├── locals: [:foo, :bar]
└── statements:
    @ StatementsNode (location: (1,0)-(41,10))
    ├── flags: ∅
    └── body: (length: 21)
        ├── @ CallNode (location: (1,0)-(1,5))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (1,0)-(1,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (1,4)-(1,5))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (1,4)-(1,5))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 1
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (3,0)-(3,9))
        │   ├── flags: newline, ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (3,4)-(3,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (3,4)-(3,9))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (3,4)-(3,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (3,8)-(3,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (3,8)-(3,9))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ IfNode (location: (5,0)-(5,14))
        │   ├── flags: newline
        │   ├── if_keyword_loc: (5,6)-(5,8) = "if"
        │   ├── predicate:
        │   │   @ CallNode (location: (5,9)-(5,14))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (5,9)-(5,12) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (5,13)-(5,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (5,13)-(5,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,0)-(5,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (5,0)-(5,5))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (5,0)-(5,3) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (5,4)-(5,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (5,4)-(5,5))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── block: ∅
        │   ├── subsequent: ∅
        │   └── end_keyword_loc: ∅
        ├── @ UnlessNode (location: (7,0)-(7,18))
        │   ├── flags: newline
        │   ├── keyword_loc: (7,6)-(7,12) = "unless"
        │   ├── predicate:
        │   │   @ CallNode (location: (7,13)-(7,18))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (7,13)-(7,16) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (7,17)-(7,18))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (7,17)-(7,18))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ StatementsNode (location: (7,0)-(7,5))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (7,0)-(7,5))
        │   │           ├── flags: newline, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :foo
        │   │           ├── message_loc: (7,0)-(7,3) = "foo"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (7,4)-(7,5))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (7,4)-(7,5))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── block: ∅
        │   ├── else_clause: ∅
        │   └── end_keyword_loc: ∅
        ├── @ WhileNode (location: (9,0)-(9,17))
        │   ├── flags: newline
        │   ├── keyword_loc: (9,6)-(9,11) = "while"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (9,12)-(9,17))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (9,12)-(9,15) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (9,16)-(9,17))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (9,16)-(9,17))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (9,0)-(9,5))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (9,0)-(9,5))
        │               ├── flags: newline, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (9,0)-(9,3) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (9,4)-(9,5))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ IntegerNode (location: (9,4)-(9,5))
        │               │           ├── flags: static_literal, decimal
        │               │           └── value: 1
        │               ├── closing_loc: ∅
        │               ├── equal_loc: ∅
        │               └── block: ∅
        ├── @ UntilNode (location: (11,0)-(11,17))
        │   ├── flags: newline
        │   ├── keyword_loc: (11,6)-(11,11) = "until"
        │   ├── do_keyword_loc: ∅
        │   ├── closing_loc: ∅
        │   ├── predicate:
        │   │   @ CallNode (location: (11,12)-(11,17))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (11,12)-(11,15) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (11,16)-(11,17))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (11,16)-(11,17))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   └── statements:
        │       @ StatementsNode (location: (11,0)-(11,5))
        │       ├── flags: ∅
        │       └── body: (length: 1)
        │           └── @ CallNode (location: (11,0)-(11,5))
        │               ├── flags: newline, ignore_visibility
        │               ├── receiver: ∅
        │               ├── call_operator_loc: ∅
        │               ├── name: :foo
        │               ├── message_loc: (11,0)-(11,3) = "foo"
        │               ├── opening_loc: ∅
        │               ├── arguments:
        │               │   @ ArgumentsNode (location: (11,4)-(11,5))
        │               │   ├── flags: ∅
        │               │   └── arguments: (length: 1)
        │               │       └── @ IntegerNode (location: (11,4)-(11,5))
        │               │           ├── flags: static_literal, decimal
        │               │           └── value: 1
        │               ├── closing_loc: ∅
        │               ├── equal_loc: ∅
        │               └── block: ∅
        ├── @ RescueModifierNode (location: (13,0)-(13,18))
        │   ├── flags: newline
        │   ├── expression:
        │   │   @ CallNode (location: (13,0)-(13,5))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (13,0)-(13,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (13,4)-(13,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (13,4)-(13,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (13,6)-(13,12) = "rescue"
        │   └── rescue_expression:
        │       @ CallNode (location: (13,13)-(13,18))
        │       ├── flags: ignore_visibility
        │       ├── receiver: ∅
        │       ├── call_operator_loc: ∅
        │       ├── name: :bar
        │       ├── message_loc: (13,13)-(13,16) = "bar"
        │       ├── opening_loc: ∅
        │       ├── arguments:
        │       │   @ ArgumentsNode (location: (13,17)-(13,18))
        │       │   ├── flags: ∅
        │       │   └── arguments: (length: 1)
        │       │       └── @ IntegerNode (location: (13,17)-(13,18))
        │       │           ├── flags: static_literal, decimal
        │       │           └── value: 2
        │       ├── closing_loc: ∅
        │       ├── equal_loc: ∅
        │       └── block: ∅
        ├── @ CallNode (location: (15,0)-(15,10))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (15,0)-(15,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (15,0)-(15,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :[]
        │   ├── message_loc: (15,3)-(15,10) = "[bar 1]"
        │   ├── opening_loc: (15,3)-(15,4) = "["
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (15,4)-(15,9))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ CallNode (location: (15,4)-(15,9))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (15,4)-(15,7) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (15,8)-(15,9))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (15,8)-(15,9))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── block: ∅
        │   ├── closing_loc: (15,9)-(15,10) = "]"
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ AndNode (location: (17,0)-(17,15))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (17,0)-(17,5))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (17,0)-(17,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (17,4)-(17,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (17,4)-(17,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (17,10)-(17,15))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (17,10)-(17,13) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (17,14)-(17,15))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (17,14)-(17,15))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (17,6)-(17,9) = "and"
        ├── @ OrNode (location: (19,0)-(19,14))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (19,0)-(19,5))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (19,0)-(19,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (19,4)-(19,5))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (19,4)-(19,5))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (19,9)-(19,14))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :bar
        │   │   ├── message_loc: (19,9)-(19,12) = "bar"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (19,13)-(19,14))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (19,13)-(19,14))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (19,6)-(19,8) = "or"
        ├── @ CallNode (location: (21,0)-(21,9))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (21,4)-(21,9))
        │   │   ├── flags: ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (21,4)-(21,7) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (21,8)-(21,9))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (21,8)-(21,9))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 1
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :!
        │   ├── message_loc: (21,0)-(21,3) = "not"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ LocalVariableWriteNode (location: (23,0)-(23,17))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── depth: 0
        │   ├── name_loc: (23,0)-(23,3) = "foo"
        │   ├── value:
        │   │   @ LocalVariableWriteNode (location: (23,6)-(23,17))
        │   │   ├── flags: ∅
        │   │   ├── name: :bar
        │   │   ├── depth: 0
        │   │   ├── name_loc: (23,6)-(23,9) = "bar"
        │   │   ├── value:
        │   │   │   @ CallNode (location: (23,12)-(23,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :baz
        │   │   │   ├── message_loc: (23,12)-(23,15) = "baz"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (23,16)-(23,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (23,16)-(23,17))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── equal_loc: ∅
        │   │   │   └── block: ∅
        │   │   └── operator_loc: (23,10)-(23,11) = "="
        │   └── operator_loc: (23,4)-(23,5) = "="
        ├── @ DefNode (location: (25,0)-(25,15))
        │   ├── flags: newline
        │   ├── name: :foo
        │   ├── name_loc: (25,4)-(25,7) = "foo"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (25,10)-(25,15))
        │   │   ├── flags: ∅
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (25,10)-(25,15))
        │   │           ├── flags: ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :bar
        │   │           ├── message_loc: (25,10)-(25,13) = "bar"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments:
        │   │           │   @ ArgumentsNode (location: (25,14)-(25,15))
        │   │           │   ├── flags: ∅
        │   │           │   └── arguments: (length: 1)
        │   │           │       └── @ IntegerNode (location: (25,14)-(25,15))
        │   │           │           ├── flags: static_literal, decimal
        │   │           │           └── value: 1
        │   │           ├── closing_loc: ∅
        │   │           ├── equal_loc: ∅
        │   │           └── block: ∅
        │   ├── locals: []
        │   ├── def_keyword_loc: (25,0)-(25,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (25,8)-(25,9) = "="
        │   └── end_keyword_loc: ∅
        ├── @ CallNode (location: (27,0)-(27,7))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ IntegerNode (location: (27,0)-(27,1))
        │   │   ├── flags: static_literal, decimal
        │   │   └── value: 1
        │   ├── call_operator_loc: (27,1)-(27,2) = "."
        │   ├── name: :foo
        │   ├── message_loc: (27,2)-(27,5) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (27,6)-(27,7))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (27,6)-(27,7))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (29,0)-(29,11))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (29,0)-(29,5))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (29,0)-(29,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: (29,1)-(29,2) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (29,2)-(29,5) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (29,5)-(29,6) = "."
        │   ├── name: :bar
        │   ├── message_loc: (29,6)-(29,9) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (29,10)-(29,11))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (29,10)-(29,11))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 2
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (31,0)-(31,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (31,0)-(31,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (31,0)-(31,5))
        │   │   │   ├── flags: ∅
        │   │   │   ├── receiver:
        │   │   │   │   @ IntegerNode (location: (31,0)-(31,1))
        │   │   │   │   ├── flags: static_literal, decimal
        │   │   │   │   └── value: 1
        │   │   │   ├── call_operator_loc: (31,1)-(31,2) = "."
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (31,2)-(31,5) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments: ∅
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── equal_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :[]
        │   │   ├── message_loc: (31,5)-(31,8) = "[2]"
        │   │   ├── opening_loc: (31,5)-(31,6) = "["
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (31,6)-(31,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (31,6)-(31,7))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: (31,7)-(31,8) = "]"
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (31,8)-(31,9) = "."
        │   ├── name: :bar
        │   ├── message_loc: (31,9)-(31,12) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,13)-(31,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (31,13)-(31,14))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (33,0)-(33,14))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (33,0)-(33,8))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (33,0)-(33,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: (33,1)-(33,2) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (33,2)-(33,5) = "foo"
        │   │   ├── opening_loc: (33,5)-(33,6) = "("
        │   │   ├── arguments:
        │   │   │   @ ArgumentsNode (location: (33,6)-(33,7))
        │   │   │   ├── flags: ∅
        │   │   │   └── arguments: (length: 1)
        │   │   │       └── @ IntegerNode (location: (33,6)-(33,7))
        │   │   │           ├── flags: static_literal, decimal
        │   │   │           └── value: 2
        │   │   ├── closing_loc: (33,7)-(33,8) = ")"
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── call_operator_loc: (33,8)-(33,9) = "."
        │   ├── name: :bar
        │   ├── message_loc: (33,9)-(33,12) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (33,13)-(33,14))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (33,13)-(33,14))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ CallNode (location: (35,0)-(35,15))
        │   ├── flags: newline
        │   ├── receiver:
        │   │   @ CallNode (location: (35,0)-(35,9))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ IntegerNode (location: (35,0)-(35,1))
        │   │   │   ├── flags: static_literal, decimal
        │   │   │   └── value: 1
        │   │   ├── call_operator_loc: (35,1)-(35,2) = "."
        │   │   ├── name: :foo
        │   │   ├── message_loc: (35,2)-(35,5) = "foo"
        │   │   ├── opening_loc: (35,5)-(35,6) = "("
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: (35,8)-(35,9) = ")"
        │   │   ├── equal_loc: ∅
        │   │   └── block:
        │   │       @ BlockArgumentNode (location: (35,6)-(35,8))
        │   │       ├── flags: ∅
        │   │       ├── expression:
        │   │       │   @ IntegerNode (location: (35,7)-(35,8))
        │   │       │   ├── flags: static_literal, decimal
        │   │       │   └── value: 2
        │   │       └── operator_loc: (35,6)-(35,7) = "&"
        │   ├── call_operator_loc: (35,9)-(35,10) = "."
        │   ├── name: :bar
        │   ├── message_loc: (35,10)-(35,13) = "bar"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (35,14)-(35,15))
        │   │   ├── flags: ∅
        │   │   └── arguments: (length: 1)
        │   │       └── @ IntegerNode (location: (35,14)-(35,15))
        │   │           ├── flags: static_literal, decimal
        │   │           └── value: 3
        │   ├── closing_loc: ∅
        │   ├── equal_loc: ∅
        │   └── block: ∅
        ├── @ AndNode (location: (37,0)-(37,17))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (37,0)-(37,6))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (37,1)-(37,6))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (37,1)-(37,4) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (37,5)-(37,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (37,5)-(37,6))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── equal_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (37,0)-(37,1) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (37,11)-(37,17))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (37,12)-(37,17))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (37,12)-(37,15) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (37,16)-(37,17))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (37,16)-(37,17))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 2
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── equal_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (37,11)-(37,12) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (37,7)-(37,10) = "and"
        ├── @ OrNode (location: (39,0)-(39,16))
        │   ├── flags: newline
        │   ├── left:
        │   │   @ CallNode (location: (39,0)-(39,6))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (39,1)-(39,6))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :foo
        │   │   │   ├── message_loc: (39,1)-(39,4) = "foo"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (39,5)-(39,6))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (39,5)-(39,6))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 1
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── equal_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (39,0)-(39,1) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   ├── right:
        │   │   @ CallNode (location: (39,10)-(39,16))
        │   │   ├── flags: ∅
        │   │   ├── receiver:
        │   │   │   @ CallNode (location: (39,11)-(39,16))
        │   │   │   ├── flags: ignore_visibility
        │   │   │   ├── receiver: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── name: :bar
        │   │   │   ├── message_loc: (39,11)-(39,14) = "bar"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (39,15)-(39,16))
        │   │   │   │   ├── flags: ∅
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ IntegerNode (location: (39,15)-(39,16))
        │   │   │   │           ├── flags: static_literal, decimal
        │   │   │   │           └── value: 2
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── equal_loc: ∅
        │   │   │   └── block: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :!
        │   │   ├── message_loc: (39,10)-(39,11) = "!"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   ├── equal_loc: ∅
        │   │   └── block: ∅
        │   └── operator_loc: (39,7)-(39,9) = "or"
        └── @ CallNode (location: (41,0)-(41,10))
            ├── flags: newline
            ├── receiver:
            │   @ CallNode (location: (41,4)-(41,10))
            │   ├── flags: ∅
            │   ├── receiver:
            │   │   @ CallNode (location: (41,5)-(41,10))
            │   │   ├── flags: ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :foo
            │   │   ├── message_loc: (41,5)-(41,8) = "foo"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments:
            │   │   │   @ ArgumentsNode (location: (41,9)-(41,10))
            │   │   │   ├── flags: ∅
            │   │   │   └── arguments: (length: 1)
            │   │   │       └── @ IntegerNode (location: (41,9)-(41,10))
            │   │   │           ├── flags: static_literal, decimal
            │   │   │           └── value: 1
            │   │   ├── closing_loc: ∅
            │   │   ├── equal_loc: ∅
            │   │   └── block: ∅
            │   ├── call_operator_loc: ∅
            │   ├── name: :!
            │   ├── message_loc: (41,4)-(41,5) = "!"
            │   ├── opening_loc: ∅
            │   ├── arguments: ∅
            │   ├── closing_loc: ∅
            │   ├── equal_loc: ∅
            │   └── block: ∅
            ├── call_operator_loc: ∅
            ├── name: :!
            ├── message_loc: (41,0)-(41,3) = "not"
            ├── opening_loc: ∅
            ├── arguments: ∅
            ├── closing_loc: ∅
            ├── equal_loc: ∅
            └── block: ∅
