@ ProgramNode (location: (0...530))
├── locals: [:foo, :bar, :exception]
└── statements:
    @ StatementsNode (location: (0...530))
    └── body: (length: 14)
        ├── @ BeginNode (location: (0...16))
        │   ├── begin_keyword_loc: (0...5) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (6...12))
        │   │   ├── keyword_loc: (6...12) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements: ∅
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (13...16) = "end"
        ├── @ BeginNode (location: (18...34))
        │   ├── begin_keyword_loc: (18...23) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (24...34))
        │   │   ├── ensure_keyword_loc: (24...30) = "ensure"
        │   │   ├── statements: ∅
        │   │   └── end_keyword_loc: (31...34) = "end"
        │   └── end_keyword_loc: (31...34) = "end"
        ├── @ BeginNode (location: (36...49))
        │   ├── begin_keyword_loc: (36...41) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (44...45))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (44...45))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (44...45) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (46...49) = "end"
        ├── @ BeginNode (location: (51...75))
        │   ├── begin_keyword_loc: (51...56) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (59...60))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (59...60))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (59...60) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (61...71))
        │   │   ├── keyword_loc: (61...67) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (70...71))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (70...71))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (70...71) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (72...75) = "end"
        ├── @ BeginNode (location: (77...105))
        │   ├── begin_keyword_loc: (77...82) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (85...90))
        │   │   └── body: (length: 2)
        │   │       ├── @ CallNode (location: (85...86))
        │   │       │   ├── receiver: ∅
        │   │       │   ├── call_operator_loc: ∅
        │   │       │   ├── message_loc: (85...86) = "a"
        │   │       │   ├── opening_loc: ∅
        │   │       │   ├── arguments: ∅
        │   │       │   ├── closing_loc: ∅
        │   │       │   ├── block: ∅
        │   │       │   ├── flags: variable_call
        │   │       │   └── name: "a"
        │   │       └── @ CallNode (location: (89...90))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (89...90) = "b"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "b"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (91...101))
        │   │   ├── keyword_loc: (91...97) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (100...101))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (100...101))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (100...101) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (102...105) = "end"
        ├── @ BeginNode (location: (107...125))
        │   ├── begin_keyword_loc: (107...112) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (113...121))
        │   │   ├── keyword_loc: (113...119) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (120...121))
        │   │   │       └── name: :A
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements: ∅
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (122...125) = "end"
        ├── @ BeginNode (location: (127...152))
        │   ├── begin_keyword_loc: (127...132) = "begin"
        │   ├── statements: ∅
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (133...148))
        │   │   ├── keyword_loc: (133...139) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (140...141))
        │   │   │       └── name: :A
        │   │   ├── operator_loc: (142...144) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (145...148))
        │   │   │   ├── name: :foo
        │   │   │   └── depth: 0
        │   │   ├── statements: ∅
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (149...152) = "end"
        ├── @ BeginNode (location: (154...204))
        │   ├── begin_keyword_loc: (154...159) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (162...163))
        │   │   └── body: (length: 1)
        │   │       └── @ CallNode (location: (162...163))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (162...163) = "a"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "a"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (164...189))
        │   │   ├── keyword_loc: (164...170) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (171...172))
        │   │   │       └── name: :A
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (175...176))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (175...176))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (175...176) = "b"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "b"
        │   │   └── consequent:
        │   │       @ RescueNode (location: (177...189))
        │   │       ├── keyword_loc: (177...183) = "rescue"
        │   │       ├── exceptions: (length: 1)
        │   │       │   └── @ ConstantReadNode (location: (184...185))
        │   │       │       └── name: :B
        │   │       ├── operator_loc: ∅
        │   │       ├── reference: ∅
        │   │       ├── statements:
        │   │       │   @ StatementsNode (location: (188...189))
        │   │       │   └── body: (length: 1)
        │   │       │       └── @ CallNode (location: (188...189))
        │   │       │           ├── receiver: ∅
        │   │       │           ├── call_operator_loc: ∅
        │   │       │           ├── message_loc: (188...189) = "c"
        │   │       │           ├── opening_loc: ∅
        │   │       │           ├── arguments: ∅
        │   │       │           ├── closing_loc: ∅
        │   │       │           ├── block: ∅
        │   │       │           ├── flags: variable_call
        │   │       │           └── name: "c"
        │   │       └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause:
        │   │   @ EnsureNode (location: (190...204))
        │   │   ├── ensure_keyword_loc: (190...196) = "ensure"
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (199...200))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (199...200))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (199...200) = "d"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "d"
        │   │   └── end_keyword_loc: (201...204) = "end"
        │   └── end_keyword_loc: (201...204) = "end"
        ├── @ BeginNode (location: (206...273))
        │   ├── begin_keyword_loc: (206...211) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (214...250))
        │   │   └── body: (length: 1)
        │   │       └── @ BeginNode (location: (214...250))
        │   │           ├── begin_keyword_loc: (214...219) = "begin"
        │   │           ├── statements:
        │   │           │   @ StatementsNode (location: (224...235))
        │   │           │   └── body: (length: 2)
        │   │           │       ├── @ LocalVariableReadNode (location: (224...227))
        │   │           │       │   ├── name: :foo
        │   │           │       │   └── depth: 0
        │   │           │       └── @ CallNode (location: (232...235))
        │   │           │           ├── receiver: ∅
        │   │           │           ├── call_operator_loc: ∅
        │   │           │           ├── message_loc: (232...235) = "bar"
        │   │           │           ├── opening_loc: ∅
        │   │           │           ├── arguments: ∅
        │   │           │           ├── closing_loc: ∅
        │   │           │           ├── block: ∅
        │   │           │           ├── flags: variable_call
        │   │           │           └── name: "bar"
        │   │           ├── rescue_clause:
        │   │           │   @ RescueNode (location: (238...244))
        │   │           │   ├── keyword_loc: (238...244) = "rescue"
        │   │           │   ├── exceptions: (length: 0)
        │   │           │   ├── operator_loc: ∅
        │   │           │   ├── reference: ∅
        │   │           │   ├── statements: ∅
        │   │           │   └── consequent: ∅
        │   │           ├── else_clause: ∅
        │   │           ├── ensure_clause: ∅
        │   │           └── end_keyword_loc: (247...250) = "end"
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (251...269))
        │   │   ├── keyword_loc: (251...257) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (260...269))
        │   │   │   └── body: (length: 2)
        │   │   │       ├── @ CallNode (location: (260...263))
        │   │   │       │   ├── receiver: ∅
        │   │   │       │   ├── call_operator_loc: ∅
        │   │   │       │   ├── message_loc: (260...263) = "baz"
        │   │   │       │   ├── opening_loc: ∅
        │   │   │       │   ├── arguments: ∅
        │   │   │       │   ├── closing_loc: ∅
        │   │   │       │   ├── block: ∅
        │   │   │       │   ├── flags: variable_call
        │   │   │       │   └── name: "baz"
        │   │   │       └── @ CallNode (location: (266...269))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (266...269) = "bar"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "bar"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (270...273) = "end"
        ├── @ BeginNode (location: (275...337))
        │   ├── begin_keyword_loc: (275...280) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (283...316))
        │   │   └── body: (length: 1)
        │   │       └── @ RescueModifierNode (location: (283...316))
        │   │           ├── expression:
        │   │           │   @ CallNode (location: (283...299))
        │   │           │   ├── receiver: ∅
        │   │           │   ├── call_operator_loc: ∅
        │   │           │   ├── message_loc: (283...288) = "raise"
        │   │           │   ├── opening_loc: (288...289) = "("
        │   │           │   ├── arguments:
        │   │           │   │   @ ArgumentsNode (location: (289...298))
        │   │           │   │   └── arguments: (length: 1)
        │   │           │   │       └── @ ConstantReadNode (location: (289...298))
        │   │           │   │           └── name: :Exception
        │   │           │   ├── closing_loc: (298...299) = ")"
        │   │           │   ├── block: ∅
        │   │           │   ├── flags: ∅
        │   │           │   └── name: "raise"
        │   │           ├── keyword_loc: (300...306) = "rescue"
        │   │           └── rescue_expression:
        │   │               @ LocalVariableWriteNode (location: (307...316))
        │   │               ├── name: :foo
        │   │               ├── depth: 0
        │   │               ├── name_loc: (307...310) = "foo"
        │   │               ├── value:
        │   │               │   @ CallNode (location: (313...316))
        │   │               │   ├── receiver: ∅
        │   │               │   ├── call_operator_loc: ∅
        │   │               │   ├── message_loc: (313...316) = "bar"
        │   │               │   ├── opening_loc: ∅
        │   │               │   ├── arguments: ∅
        │   │               │   ├── closing_loc: ∅
        │   │               │   ├── block: ∅
        │   │               │   ├── flags: variable_call
        │   │               │   └── name: "bar"
        │   │               └── operator_loc: (311...312) = "="
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (317...333))
        │   │   ├── keyword_loc: (317...323) = "rescue"
        │   │   ├── exceptions: (length: 1)
        │   │   │   └── @ ConstantReadNode (location: (324...333))
        │   │   │       └── name: :Exception
        │   │   ├── operator_loc: ∅
        │   │   ├── reference: ∅
        │   │   ├── statements: ∅
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (334...337) = "end"
        ├── @ BeginNode (location: (339...374))
        │   ├── begin_keyword_loc: (339...344) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (347...350))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (347...350))
        │   │           ├── name: :foo
        │   │           └── depth: 0
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (351...370))
        │   │   ├── keyword_loc: (351...357) = "rescue"
        │   │   ├── exceptions: (length: 0)
        │   │   ├── operator_loc: (358...360) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (361...364))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (367...370))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableReadNode (location: (367...370))
        │   │   │           ├── name: :bar
        │   │   │           └── depth: 0
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (371...374) = "end"
        ├── @ BeginNode (location: (376...428))
        │   ├── begin_keyword_loc: (376...381) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (384...387))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (384...387))
        │   │           ├── name: :foo
        │   │           └── depth: 0
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (388...424))
        │   │   ├── keyword_loc: (388...394) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (395...404))
        │   │   │   │   └── name: :Exception
        │   │   │   └── @ ConstantReadNode (location: (406...411))
        │   │   │       └── name: :Other
        │   │   ├── operator_loc: (412...414) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (415...418))
        │   │   │   ├── name: :bar
        │   │   │   └── depth: 0
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (421...424))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ LocalVariableReadNode (location: (421...424))
        │   │   │           ├── name: :bar
        │   │   │           └── depth: 0
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (425...428) = "end"
        ├── @ BeginNode (location: (430...487))
        │   ├── begin_keyword_loc: (430...435) = "begin"
        │   ├── statements:
        │   │   @ StatementsNode (location: (438...441))
        │   │   └── body: (length: 1)
        │   │       └── @ LocalVariableReadNode (location: (438...441))
        │   │           ├── name: :bar
        │   │           └── depth: 0
        │   ├── rescue_clause:
        │   │   @ RescueNode (location: (442...483))
        │   │   ├── keyword_loc: (442...448) = "rescue"
        │   │   ├── exceptions: (length: 2)
        │   │   │   ├── @ ConstantReadNode (location: (449...458))
        │   │   │   │   └── name: :SomeError
        │   │   │   └── @ SplatNode (location: (460...464))
        │   │   │       ├── operator_loc: (460...461) = "*"
        │   │   │       └── expression:
        │   │   │           @ LocalVariableReadNode (location: (461...464))
        │   │   │           ├── name: :bar
        │   │   │           └── depth: 0
        │   │   ├── operator_loc: (465...467) = "=>"
        │   │   ├── reference:
        │   │   │   @ LocalVariableTargetNode (location: (468...477))
        │   │   │   ├── name: :exception
        │   │   │   └── depth: 0
        │   │   ├── statements:
        │   │   │   @ StatementsNode (location: (480...483))
        │   │   │   └── body: (length: 1)
        │   │   │       └── @ CallNode (location: (480...483))
        │   │   │           ├── receiver: ∅
        │   │   │           ├── call_operator_loc: ∅
        │   │   │           ├── message_loc: (480...483) = "baz"
        │   │   │           ├── opening_loc: ∅
        │   │   │           ├── arguments: ∅
        │   │   │           ├── closing_loc: ∅
        │   │   │           ├── block: ∅
        │   │   │           ├── flags: variable_call
        │   │   │           └── name: "baz"
        │   │   └── consequent: ∅
        │   ├── else_clause: ∅
        │   ├── ensure_clause: ∅
        │   └── end_keyword_loc: (484...487) = "end"
        └── @ SingletonClassNode (location: (489...530))
            ├── locals: []
            ├── class_keyword_loc: (489...494) = "class"
            ├── operator_loc: (495...497) = "<<"
            ├── expression:
            │   @ SelfNode (location: (498...502))
            ├── body:
            │   @ StatementsNode (location: (505...526))
            │   └── body: (length: 1)
            │       └── @ RescueModifierNode (location: (505...526))
            │           ├── expression:
            │           │   @ UndefNode (location: (505...515))
            │           │   ├── names: (length: 1)
            │           │   │   └── @ SymbolNode (location: (511...515))
            │           │   │       ├── opening_loc: (511...512) = ":"
            │           │   │       ├── value_loc: (512...515) = "bar"
            │           │   │       ├── closing_loc: ∅
            │           │   │       └── unescaped: "bar"
            │           │   └── keyword_loc: (505...510) = "undef"
            │           ├── keyword_loc: (516...522) = "rescue"
            │           └── rescue_expression:
            │               @ NilNode (location: (523...526))
            └── end_keyword_loc: (527...530) = "end"
