@ ProgramNode (location: (1,0)-(33,21))
├── locals: [:a]
└── statements:
    @ StatementsNode (location: (1,0)-(33,21))
    └── body: (length: 13)
        ├── @ 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:
        │       @ NilNode (location: (1,11)-(1,14))
        ├── @ RescueModifierNode (location: (3,0)-(4,3))
        │   ├── expression:
        │   │   @ CallNode (location: (3,0)-(3,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (3,0)-(3,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (3,4)-(3,10) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (4,0)-(4,3))
        ├── @ RescueModifierNode (location: (6,0)-(6,16))
        │   ├── expression:
        │   │   @ BreakNode (location: (6,0)-(6,5))
        │   │   ├── arguments: ∅
        │   │   └── keyword_loc: (6,0)-(6,5) = "break"
        │   ├── keyword_loc: (6,6)-(6,12) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (6,13)-(6,16))
        ├── @ RescueModifierNode (location: (8,0)-(8,15))
        │   ├── expression:
        │   │   @ NextNode (location: (8,0)-(8,4))
        │   │   ├── arguments: ∅
        │   │   └── keyword_loc: (8,0)-(8,4) = "next"
        │   ├── keyword_loc: (8,5)-(8,11) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (8,12)-(8,15))
        ├── @ RescueModifierNode (location: (10,0)-(10,17))
        │   ├── expression:
        │   │   @ ReturnNode (location: (10,0)-(10,6))
        │   │   ├── keyword_loc: (10,0)-(10,6) = "return"
        │   │   └── arguments: ∅
        │   ├── keyword_loc: (10,7)-(10,13) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (10,14)-(10,17))
        ├── @ RescueModifierNode (location: (12,0)-(12,19))
        │   ├── expression:
        │   │   @ CallNode (location: (12,0)-(12,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (12,0)-(12,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (12,4)-(12,10) = "rescue"
        │   └── rescue_expression:
        │       @ OrNode (location: (12,11)-(12,19))
        │       ├── left:
        │       │   @ NilNode (location: (12,11)-(12,14))
        │       ├── right:
        │       │   @ IntegerNode (location: (12,18)-(12,19))
        │       │   └── flags: decimal
        │       └── operator_loc: (12,15)-(12,17) = "||"
        ├── @ RescueModifierNode (location: (14,0)-(14,22))
        │   ├── expression:
        │   │   @ CallNode (location: (14,0)-(14,3))
        │   │   ├── flags: variable_call, ignore_visibility
        │   │   ├── receiver: ∅
        │   │   ├── call_operator_loc: ∅
        │   │   ├── name: :foo
        │   │   ├── message_loc: (14,0)-(14,3) = "foo"
        │   │   ├── opening_loc: ∅
        │   │   ├── arguments: ∅
        │   │   ├── closing_loc: ∅
        │   │   └── block: ∅
        │   ├── keyword_loc: (14,4)-(14,10) = "rescue"
        │   └── rescue_expression:
        │       @ IfNode (location: (14,11)-(14,22))
        │       ├── if_keyword_loc: ∅
        │       ├── predicate:
        │       │   @ NilNode (location: (14,11)-(14,14))
        │       ├── then_keyword_loc: (14,15)-(14,16) = "?"
        │       ├── statements:
        │       │   @ StatementsNode (location: (14,17)-(14,18))
        │       │   └── body: (length: 1)
        │       │       └── @ IntegerNode (location: (14,17)-(14,18))
        │       │           └── flags: decimal
        │       ├── consequent:
        │       │   @ ElseNode (location: (14,19)-(14,22))
        │       │   ├── else_keyword_loc: (14,19)-(14,20) = ":"
        │       │   ├── statements:
        │       │   │   @ StatementsNode (location: (14,21)-(14,22))
        │       │   │   └── body: (length: 1)
        │       │   │       └── @ IntegerNode (location: (14,21)-(14,22))
        │       │   │           └── flags: decimal
        │       │   └── end_keyword_loc: ∅
        │       └── end_keyword_loc: ∅
        ├── @ BeginNode (location: (16,0)-(16,24))
        │   ├── begin_keyword_loc: (16,0)-(16,5) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (16,7)-(16,8))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (16,7)-(16,8))
        │   │           ├── flags: variable_call, ignore_visibility
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── name: :a
        │   │           ├── message_loc: (16,7)-(16,8) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           └── block: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (16,10)-(16,19))
        │   │   ├── keyword_loc: (16,10)-(16,16) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ SplatNode (location: (16,17)-(16,19))
        │   │   │       ├── operator_loc: (16,17)-(16,18) = "*"
        │   │   │       └── expression:
        │   │   │           @ CallNode (location: (16,18)-(16,19))
        │   │   │           ├── flags: variable_call, ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :b
        │   │   │           ├── message_loc: (16,18)-(16,19) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements: ∅
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (16,21)-(16,24) = "end"
        ├── @ CallNode (location: (18,0)-(20,3))
        │   ├── flags: ignore_visibility
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── name: :foo
        │   ├── message_loc: (18,0)-(18,3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments: ∅
        │   ├── closing_loc: ∅
        │   └── block:
        │       @ BlockNode (location: (18,4)-(20,3))
        │       ├── locals: [:x]
        │       ├── parameters:
        │       │   @ BlockParametersNode (location: (18,7)-(18,10))
        │       │   ├── parameters:
        │       │   │   @ ParametersNode (location: (18,8)-(18,9))
        │       │   │   ├── requireds: (length: 1)
        │       │   │   │   └── @ RequiredParameterNode (location: (18,8)-(18,9))
        │       │   │   │       ├── flags: ∅
        │       │   │   │       └── name: :x
        │       │   │   ├── optionals: (length: 0)
        │       │   │   ├── rest: ∅
        │       │   │   ├── posts: (length: 0)
        │       │   │   ├── keywords: (length: 0)
        │       │   │   ├── keyword_rest: ∅
        │       │   │   └── block: ∅
        │       │   ├── locals: (length: 0)
        │       │   ├── opening_loc: (18,7)-(18,8) = "|"
        │       │   └── closing_loc: (18,9)-(18,10) = "|"
        │       ├── body:
        │       │   @ StatementsNode (location: (19,2)-(19,40))
        │       │   └── body: (length: 1)
        │       │       └── @ RescueModifierNode (location: (19,2)-(19,40))
        │       │           ├── expression:
        │       │           │   @ CallNode (location: (19,2)-(19,8))
        │       │           │   ├── flags: ignore_visibility
        │       │           │   ├── receiver: ∅
        │       │           │   ├── call_operator_loc: ∅
        │       │           │   ├── name: :bar
        │       │           │   ├── message_loc: (19,2)-(19,5) = "bar"
        │       │           │   ├── opening_loc: (19,5)-(19,6) = "("
        │       │           │   ├── arguments:
        │       │           │   │   @ ArgumentsNode (location: (19,6)-(19,7))
        │       │           │   │   ├── flags: ∅
        │       │           │   │   └── arguments: (length: 1)
        │       │           │   │       └── @ CallNode (location: (19,6)-(19,7))
        │       │           │   │           ├── flags: variable_call, ignore_visibility
        │       │           │   │           ├── receiver: ∅
        │       │           │   │           ├── call_operator_loc: ∅
        │       │           │   │           ├── name: :y
        │       │           │   │           ├── message_loc: (19,6)-(19,7) = "y"
        │       │           │   │           ├── opening_loc: ∅
        │       │           │   │           ├── arguments: ∅
        │       │           │   │           ├── closing_loc: ∅
        │       │           │   │           └── block: ∅
        │       │           │   ├── closing_loc: (19,7)-(19,8) = ")"
        │       │           │   └── block: ∅
        │       │           ├── keyword_loc: (19,9)-(19,15) = "rescue"
        │       │           └── rescue_expression:
        │       │               @ CallNode (location: (19,16)-(19,40))
        │       │               ├── flags: ignore_visibility
        │       │               ├── receiver: ∅
        │       │               ├── call_operator_loc: ∅
        │       │               ├── name: :ArgumentError
        │       │               ├── message_loc: (19,16)-(19,29) = "ArgumentError"
        │       │               ├── opening_loc: ∅
        │       │               ├── arguments:
        │       │               │   @ ArgumentsNode (location: (19,30)-(19,40))
        │       │               │   ├── flags: ∅
        │       │               │   └── arguments: (length: 1)
        │       │               │       └── @ CallNode (location: (19,30)-(19,40))
        │       │               │           ├── flags: ignore_visibility
        │       │               │           ├── receiver: ∅
        │       │               │           ├── call_operator_loc: ∅
        │       │               │           ├── name: :fail
        │       │               │           ├── message_loc: (19,30)-(19,34) = "fail"
        │       │               │           ├── opening_loc: ∅
        │       │               │           ├── arguments:
        │       │               │           │   @ ArgumentsNode (location: (19,35)-(19,40))
        │       │               │           │   ├── flags: ∅
        │       │               │           │   └── arguments: (length: 1)
        │       │               │           │       └── @ StringNode (location: (19,35)-(19,40))
        │       │               │           │           ├── flags: ∅
        │       │               │           │           ├── opening_loc: (19,35)-(19,36) = "\""
        │       │               │           │           ├── content_loc: (19,36)-(19,39) = "baz"
        │       │               │           │           ├── closing_loc: (19,39)-(19,40) = "\""
        │       │               │           │           └── unescaped: "baz"
        │       │               │           ├── closing_loc: ∅
        │       │               │           └── block: ∅
        │       │               ├── closing_loc: ∅
        │       │               └── block: ∅
        │       ├── opening_loc: (18,4)-(18,6) = "do"
        │       └── closing_loc: (20,0)-(20,3) = "end"
        ├── @ IfNode (location: (22,0)-(24,3))
        │   ├── if_keyword_loc: (22,0)-(22,2) = "if"
        │   ├── predicate:
        │   │   @ LocalVariableWriteNode (location: (22,3)-(22,21))
        │   │   ├── name: :a
        │   │   ├── depth: 0
        │   │   ├── name_loc: (22,3)-(22,4) = "a"
        │   │   ├── value:
        │   │   │   @ RescueModifierNode (location: (22,7)-(22,21))
        │   │   │   ├── expression:
        │   │   │   │   @ CallNode (location: (22,7)-(22,10))
        │   │   │   │   ├── flags: variable_call, ignore_visibility
        │   │   │   │   ├── receiver: ∅
        │   │   │   │   ├── call_operator_loc: ∅
        │   │   │   │   ├── name: :foo
        │   │   │   │   ├── message_loc: (22,7)-(22,10) = "foo"
        │   │   │   │   ├── opening_loc: ∅
        │   │   │   │   ├── arguments: ∅
        │   │   │   │   ├── closing_loc: ∅
        │   │   │   │   └── block: ∅
        │   │   │   ├── keyword_loc: (22,11)-(22,17) = "rescue"
        │   │   │   └── rescue_expression:
        │   │   │       @ NilNode (location: (22,18)-(22,21))
        │   │   └── operator_loc: (22,5)-(22,6) = "="
        │   ├── then_keyword_loc: ∅
        │   ├── statements:
        │   │   @ 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: ∅
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (24,0)-(24,3) = "end"
        ├── @ DefNode (location: (26,0)-(26,44))
        │   ├── name: :some_method
        │   ├── name_loc: (26,4)-(26,15) = "some_method"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ StatementsNode (location: (26,18)-(26,44))
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (26,18)-(26,44))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (26,18)-(26,33))
        │   │           │   ├── flags: ignore_visibility
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── name: :other_method
        │   │           │   ├── message_loc: (26,18)-(26,30) = "other_method"
        │   │           │   ├── opening_loc: ∅
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (26,31)-(26,33))
        │   │           │   │   ├── flags: ∅
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ IntegerNode (location: (26,31)-(26,33))
        │   │           │   │           └── flags: decimal
        │   │           │   ├── closing_loc: ∅
        │   │           │   └── block: ∅
        │   │           ├── keyword_loc: (26,34)-(26,40) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ NilNode (location: (26,41)-(26,44))
        │   ├── locals: []
        │   ├── def_keyword_loc: (26,0)-(26,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: (26,16)-(26,17) = "="
        │   └── end_keyword_loc: ∅
        ├── @ DefNode (location: (28,0)-(31,3))
        │   ├── name: :a
        │   ├── name_loc: (28,4)-(28,5) = "a"
        │   ├── receiver: ∅
        │   ├── parameters: ∅
        │   ├── body:
        │   │   @ BeginNode (location: (29,2)-(31,3))
        │   │   ├── begin_keyword_loc: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (29,2)-(29,6))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (29,2)-(29,6))
        │   │   │           ├── flags: ignore_visibility
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── name: :a
        │   │   │           ├── message_loc: (29,2)-(29,3) = "a"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments:
        │   │   │           │   @ ArgumentsNode (location: (29,4)-(29,6))
        │   │   │           │   ├── flags: ∅
        │   │   │           │   └── arguments: (length: 1)
        │   │   │           │       └── @ KeywordHashNode (location: (29,4)-(29,6))
        │   │   │           │           ├── flags: symbol_keys
        │   │   │           │           └── elements: (length: 1)
        │   │   │           │               └── @ AssocNode (location: (29,4)-(29,6))
        │   │   │           │                   ├── key:
        │   │   │           │                   │   @ SymbolNode (location: (29,4)-(29,6))
        │   │   │           │                   │   ├── flags: forced_us_ascii_encoding
        │   │   │           │                   │   ├── opening_loc: ∅
        │   │   │           │                   │   ├── value_loc: (29,4)-(29,5) = "b"
        │   │   │           │                   │   ├── closing_loc: (29,5)-(29,6) = ":"
        │   │   │           │                   │   └── unescaped: "b"
        │   │   │           │                   ├── value:
        │   │   │           │                   │   @ ImplicitNode (location: (29,4)-(29,6))
        │   │   │           │                   │   └── value:
        │   │   │           │                   │       @ CallNode (location: (29,4)-(29,6))
        │   │   │           │                   │       ├── flags: ignore_visibility
        │   │   │           │                   │       ├── receiver: ∅
        │   │   │           │                   │       ├── call_operator_loc: ∅
        │   │   │           │                   │       ├── name: :b
        │   │   │           │                   │       ├── message_loc: (29,4)-(29,5) = "b"
        │   │   │           │                   │       ├── opening_loc: ∅
        │   │   │           │                   │       ├── arguments: ∅
        │   │   │           │                   │       ├── closing_loc: ∅
        │   │   │           │                   │       └── block: ∅
        │   │   │           │                   └── operator_loc: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           └── block: ∅
        │   │   ├── rescue_clause:
        │   │   │   @ RescueNode (location: (30,0)-(30,6))
        │   │   │   ├── keyword_loc: (30,0)-(30,6) = "rescue"
        │   │   │   ├── exceptions: (length: 0)
        │   │   │   ├── operator_loc: ∅
        │   │   │   ├── reference: ∅
        │   │   │   ├── statements: ∅
        │   │   │   └── consequent: ∅
        │   │   ├── else_clause: ∅
        │   │   ├── ensure_clause: ∅
        │   │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        │   ├── locals: []
        │   ├── def_keyword_loc: (28,0)-(28,3) = "def"
        │   ├── operator_loc: ∅
        │   ├── lparen_loc: ∅
        │   ├── rparen_loc: ∅
        │   ├── equal_loc: ∅
        │   └── end_keyword_loc: (31,0)-(31,3) = "end"
        └── @ RescueModifierNode (location: (33,0)-(33,21))
            ├── expression:
            │   @ IfNode (location: (33,0)-(33,10))
            │   ├── if_keyword_loc: (33,4)-(33,6) = "if"
            │   ├── predicate:
            │   │   @ CallNode (location: (33,7)-(33,10))
            │   │   ├── flags: variable_call, ignore_visibility
            │   │   ├── receiver: ∅
            │   │   ├── call_operator_loc: ∅
            │   │   ├── name: :bar
            │   │   ├── message_loc: (33,7)-(33,10) = "bar"
            │   │   ├── opening_loc: ∅
            │   │   ├── arguments: ∅
            │   │   ├── closing_loc: ∅
            │   │   └── block: ∅
            │   ├── then_keyword_loc: ∅
            │   ├── statements:
            │   │   @ StatementsNode (location: (33,0)-(33,3))
            │   │   └── body: (length: 1)
            │   │       └── @ CallNode (location: (33,0)-(33,3))
            │   │           ├── flags: variable_call, ignore_visibility
            │   │           ├── receiver: ∅
            │   │           ├── call_operator_loc: ∅
            │   │           ├── name: :foo
            │   │           ├── message_loc: (33,0)-(33,3) = "foo"
            │   │           ├── opening_loc: ∅
            │   │           ├── arguments: ∅
            │   │           ├── closing_loc: ∅
            │   │           └── block: ∅
            │   ├── consequent: ∅
            │   └── end_keyword_loc: ∅
            ├── keyword_loc: (33,11)-(33,17) = "rescue"
            └── rescue_expression:
                @ CallNode (location: (33,18)-(33,21))
                ├── flags: variable_call, ignore_visibility
                ├── receiver: ∅
                ├── call_operator_loc: ∅
                ├── name: :baz
                ├── message_loc: (33,18)-(33,21) = "baz"
                ├── opening_loc: ∅
                ├── arguments: ∅
                ├── closing_loc: ∅
                └── block: ∅
