@ ProgramNode (location: (0...299))
├── locals: []
└── statements:
    @ StatementsNode (location: (0...299))
    └── body: (length: 11)
        ├── @ IfNode (location: (0...20))
        │   ├── if_keyword_loc: (0...2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (3...7))
        │   ├── statements:
        │   │   @ StatementsNode (location: (10...16))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (10...16))
        │   │           ├── opening_loc: (10...11) = "\""
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ EmbeddedStatementsNode (location: (11...14))
        │   │           │   │   ├── opening_loc: (11...13) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (13...14) = "}"
        │   │           │   └── @ StringNode (location: (14...15))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (14...15) = "a"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "a"
        │   │           └── closing_loc: (15...16) = "\""
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (17...20) = "end"
        ├── @ IfNode (location: (21...68))
        │   ├── if_keyword_loc: (21...23) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (24...28))
        │   ├── statements:
        │   │   @ StatementsNode (location: (31...64))
        │   │   └── body: (length: 2)
        │   │       ├── @ InterpolatedStringNode (location: (31...41))
        │   │       │   ├── opening_loc: (31...41) = "<<-HEREDOC"
        │   │       │   ├── parts: (length: 3)
        │   │       │   │   ├── @ StringNode (location: (42...44))
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (42...44) = "a\n"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a\n"
        │   │       │   │   ├── @ EmbeddedStatementsNode (location: (44...47))
        │   │       │   │   │   ├── opening_loc: (44...46) = "\#{"
        │   │       │   │   │   ├── statements: ∅
        │   │       │   │   │   └── closing_loc: (46...47) = "}"
        │   │       │   │   └── @ StringNode (location: (47...51))
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (47...51) = "a\nb\n"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "a\nb\n"
        │   │       │   └── closing_loc: (51...61) = "  HEREDOC\n"
        │   │       └── @ CallNode (location: (63...64))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (63...64) = "x"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: "x"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (65...68) = "end"
        ├── @ InterpolatedStringNode (location: (69...79))
        │   ├── opening_loc: (69...79) = "<<-HEREDOC"
        │   ├── parts: (length: 7)
        │   │   ├── @ StringNode (location: (80...89))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (80...89) = "\\\#{}\\\#{}\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\#{}\#{}\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (89...92))
        │   │   │   ├── opening_loc: (89...91) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (91...92) = "}"
        │   │   ├── @ StringNode (location: (92...93))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (92...93) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (93...96))
        │   │   │   ├── opening_loc: (93...95) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (95...96) = "}"
        │   │   ├── @ StringNode (location: (96...97))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (96...97) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (97...100))
        │   │   │   ├── opening_loc: (97...99) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (99...100) = "}"
        │   │   └── @ StringNode (location: (100...101))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (100...101) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (101...109) = "HEREDOC\n"
        ├── @ RescueModifierNode (location: (109...130))
        │   ├── expression:
        │   │   @ InterpolatedStringNode (location: (109...119))
        │   │   ├── opening_loc: (109...119) = "<<-HEREDOC"
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ EmbeddedStatementsNode (location: (131...134))
        │   │   │   │   ├── opening_loc: (131...133) = "\#{"
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── closing_loc: (133...134) = "}"
        │   │   │   └── @ StringNode (location: (134...137))
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (134...137) = "\na\n"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "\na\n"
        │   │   └── closing_loc: (137...145) = "HEREDOC\n"
        │   ├── keyword_loc: (120...126) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (127...130))
        ├── @ InterpolatedStringNode (location: (145...151))
        │   ├── opening_loc: (145...146) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (146...147))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (146...147) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (147...150))
        │   │       ├── operator_loc: (147...148) = "#"
        │   │       └── variable:
        │   │           @ NumberedReferenceReadNode (location: (148...150))
        │   │           └── number: 1
        │   └── closing_loc: (150...151) = "\""
        ├── @ InterpolatedStringNode (location: (152...158))
        │   ├── opening_loc: (152...153) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (153...154))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (153...154) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (154...157))
        │   │       ├── operator_loc: (154...155) = "#"
        │   │       └── variable:
        │   │           @ GlobalVariableReadNode (location: (155...157))
        │   │           └── name: :$a
        │   └── closing_loc: (157...158) = "\""
        ├── @ InterpolatedStringNode (location: (159...165))
        │   ├── opening_loc: (159...160) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (160...161))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (160...161) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (161...164))
        │   │       ├── operator_loc: (161...162) = "#"
        │   │       └── variable:
        │   │           @ InstanceVariableReadNode (location: (162...164))
        │   │           └── name: :@a
        │   └── closing_loc: (164...165) = "\""
        ├── @ InterpolatedStringNode (location: (166...173))
        │   ├── opening_loc: (166...167) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (167...168))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (167...168) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (168...172))
        │   │       ├── operator_loc: (168...169) = "#"
        │   │       └── variable:
        │   │           @ ClassVariableReadNode (location: (169...172))
        │   │           └── name: :@@a
        │   └── closing_loc: (172...173) = "\""
        ├── @ IfNode (location: (174...225))
        │   ├── if_keyword_loc: (174...176) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (177...181))
        │   ├── statements:
        │   │   @ StatementsNode (location: (184...201))
        │   │   └── body: (length: 1)
        │   │       └── @ ReturnNode (location: (184...201))
        │   │           ├── keyword_loc: (184...190) = "return"
        │   │           └── arguments:
        │   │               @ ArgumentsNode (location: (191...201))
        │   │               └── arguments: (length: 1)
        │   │                   └── @ InterpolatedStringNode (location: (191...201))
        │   │                       ├── opening_loc: (191...201) = "<<-HEREDOC"
        │   │                       ├── parts: (length: 3)
        │   │                       │   ├── @ StringNode (location: (202...206))
        │   │                       │   │   ├── opening_loc: ∅
        │   │                       │   │   ├── content_loc: (202...206) = "    "
        │   │                       │   │   ├── closing_loc: ∅
        │   │                       │   │   └── unescaped: "    "
        │   │                       │   ├── @ EmbeddedStatementsNode (location: (206...211))
        │   │                       │   │   ├── opening_loc: (206...208) = "\#{"
        │   │                       │   │   ├── statements:
        │   │                       │   │   │   @ StatementsNode (location: (208...210))
        │   │                       │   │   │   └── body: (length: 1)
        │   │                       │   │   │       └── @ IntegerNode (location: (208...210))
        │   │                       │   │   │           └── flags: decimal
        │   │                       │   │   └── closing_loc: (210...211) = "}"
        │   │                       │   └── @ StringNode (location: (211...212))
        │   │                       │       ├── opening_loc: ∅
        │   │                       │       ├── content_loc: (211...212) = "\n"
        │   │                       │       ├── closing_loc: ∅
        │   │                       │       └── unescaped: "\n"
        │   │                       └── closing_loc: (212...222) = "  HEREDOC\n"
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (222...225) = "end"
        ├── @ CallNode (location: (226...241))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (226...229) = "foo"
        │   ├── opening_loc: (229...230) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (230...240))
        │   │   └── arguments: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (230...240))
        │   │           ├── opening_loc: (230...240) = "<<-HEREDOC"
        │   │           ├── parts: (length: 3)
        │   │           │   ├── @ StringNode (location: (242...244))
        │   │           │   │   ├── opening_loc: ∅
        │   │           │   │   ├── content_loc: (242...244) = "  "
        │   │           │   │   ├── closing_loc: ∅
        │   │           │   │   └── unescaped: "  "
        │   │           │   ├── @ EmbeddedStatementsNode (location: (244...250))
        │   │           │   │   ├── opening_loc: (244...246) = "\#{"
        │   │           │   │   ├── statements:
        │   │           │   │   │   @ StatementsNode (location: (246...249))
        │   │           │   │   │   └── body: (length: 1)
        │   │           │   │   │       └── @ CallNode (location: (246...249))
        │   │           │   │   │           ├── receiver: ∅
        │   │           │   │   │           ├── call_operator_loc: ∅
        │   │           │   │   │           ├── message_loc: (246...249) = "bar"
        │   │           │   │   │           ├── opening_loc: ∅
        │   │           │   │   │           ├── arguments: ∅
        │   │           │   │   │           ├── closing_loc: ∅
        │   │           │   │   │           ├── block: ∅
        │   │           │   │   │           ├── flags: variable_call
        │   │           │   │   │           └── name: "bar"
        │   │           │   │   └── closing_loc: (249...250) = "}"
        │   │           │   └── @ StringNode (location: (250...251))
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (250...251) = "\n"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "\n"
        │   │           └── closing_loc: (251...259) = "HEREDOC\n"
        │   ├── closing_loc: (240...241) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        └── @ CallNode (location: (259...299))
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── message_loc: (259...262) = "foo"
            ├── opening_loc: (262...263) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (263...273))
            │   └── arguments: (length: 1)
            │       └── @ InterpolatedStringNode (location: (263...273))
            │           ├── opening_loc: (263...273) = "<<-HEREDOC"
            │           ├── parts: (length: 3)
            │           │   ├── @ StringNode (location: (281...283))
            │           │   │   ├── opening_loc: ∅
            │           │   │   ├── content_loc: (281...283) = "  "
            │           │   │   ├── closing_loc: ∅
            │           │   │   └── unescaped: "  "
            │           │   ├── @ EmbeddedStatementsNode (location: (283...289))
            │           │   │   ├── opening_loc: (283...285) = "\#{"
            │           │   │   ├── statements:
            │           │   │   │   @ StatementsNode (location: (285...288))
            │           │   │   │   └── body: (length: 1)
            │           │   │   │       └── @ CallNode (location: (285...288))
            │           │   │   │           ├── receiver: ∅
            │           │   │   │           ├── call_operator_loc: ∅
            │           │   │   │           ├── message_loc: (285...288) = "bar"
            │           │   │   │           ├── opening_loc: ∅
            │           │   │   │           ├── arguments: ∅
            │           │   │   │           ├── closing_loc: ∅
            │           │   │   │           ├── block: ∅
            │           │   │   │           ├── flags: variable_call
            │           │   │   │           └── name: "bar"
            │           │   │   └── closing_loc: (288...289) = "}"
            │           │   └── @ StringNode (location: (289...290))
            │           │       ├── opening_loc: ∅
            │           │       ├── content_loc: (289...290) = "\n"
            │           │       ├── closing_loc: ∅
            │           │       └── unescaped: "\n"
            │           └── closing_loc: (290...298) = "HEREDOC\n"
            ├── closing_loc: (273...274) = ")"
            ├── block:
            │   @ BlockNode (location: (275...299))
            │   ├── locals: [:x]
            │   ├── parameters:
            │   │   @ BlockParametersNode (location: (277...280))
            │   │   ├── parameters:
            │   │   │   @ ParametersNode (location: (278...279))
            │   │   │   ├── requireds: (length: 1)
            │   │   │   │   └── @ RequiredParameterNode (location: (278...279))
            │   │   │   │       └── name: :x
            │   │   │   ├── optionals: (length: 0)
            │   │   │   ├── rest: ∅
            │   │   │   ├── posts: (length: 0)
            │   │   │   ├── keywords: (length: 0)
            │   │   │   ├── keyword_rest: ∅
            │   │   │   └── block: ∅
            │   │   ├── locals: (length: 0)
            │   │   ├── opening_loc: (277...278) = "|"
            │   │   └── closing_loc: (279...280) = "|"
            │   ├── body: ∅
            │   ├── opening_loc: (275...276) = "{"
            │   └── closing_loc: (298...299) = "}"
            ├── flags: ∅
            └── name: "foo"
