@ ProgramNode (location: (1,0)-(37,1))
├── locals: []
└── statements:
    @ StatementsNode (location: (1,0)-(37,1))
    └── body: (length: 11)
        ├── @ IfNode (location: (1,0)-(3,3))
        │   ├── if_keyword_loc: (1,0)-(1,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (1,3)-(1,7))
        │   ├── statements:
        │   │   @ StatementsNode (location: (2,2)-(2,8))
        │   │   └── body: (length: 1)
        │   │       └── @ InterpolatedStringNode (location: (2,2)-(2,8))
        │   │           ├── opening_loc: (2,2)-(2,3) = "\""
        │   │           ├── parts: (length: 2)
        │   │           │   ├── @ EmbeddedStatementsNode (location: (2,3)-(2,6))
        │   │           │   │   ├── opening_loc: (2,3)-(2,5) = "\#{"
        │   │           │   │   ├── statements: ∅
        │   │           │   │   └── closing_loc: (2,5)-(2,6) = "}"
        │   │           │   └── @ StringNode (location: (2,6)-(2,7))
        │   │           │       ├── flags: ∅
        │   │           │       ├── opening_loc: ∅
        │   │           │       ├── content_loc: (2,6)-(2,7) = "a"
        │   │           │       ├── closing_loc: ∅
        │   │           │       └── unescaped: "a"
        │   │           └── closing_loc: (2,7)-(2,8) = "\""
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (3,0)-(3,3) = "end"
        ├── @ IfNode (location: (4,0)-(11,3))
        │   ├── if_keyword_loc: (4,0)-(4,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (4,3)-(4,7))
        │   ├── statements:
        │   │   @ StatementsNode (location: (5,2)-(10,3))
        │   │   └── body: (length: 2)
        │   │       ├── @ InterpolatedStringNode (location: (5,2)-(5,12))
        │   │       │   ├── opening_loc: (5,2)-(5,12) = "<<-HEREDOC"
        │   │       │   ├── parts: (length: 3)
        │   │       │   │   ├── @ StringNode (location: (6,0)-(7,0))
        │   │       │   │   │   ├── flags: ∅
        │   │       │   │   │   ├── opening_loc: ∅
        │   │       │   │   │   ├── content_loc: (6,0)-(7,0) = "a\n"
        │   │       │   │   │   ├── closing_loc: ∅
        │   │       │   │   │   └── unescaped: "a\n"
        │   │       │   │   ├── @ EmbeddedStatementsNode (location: (7,0)-(7,3))
        │   │       │   │   │   ├── opening_loc: (7,0)-(7,2) = "\#{"
        │   │       │   │   │   ├── statements: ∅
        │   │       │   │   │   └── closing_loc: (7,2)-(7,3) = "}"
        │   │       │   │   └── @ StringNode (location: (7,3)-(9,0))
        │   │       │   │       ├── flags: ∅
        │   │       │   │       ├── opening_loc: ∅
        │   │       │   │       ├── content_loc: (7,3)-(9,0) = "a\nb\n"
        │   │       │   │       ├── closing_loc: ∅
        │   │       │   │       └── unescaped: "a\nb\n"
        │   │       │   └── closing_loc: (9,0)-(10,0) = "  HEREDOC\n"
        │   │       └── @ CallNode (location: (10,2)-(10,3))
        │   │           ├── receiver: ∅
        │   │           ├── call_operator_loc: ∅
        │   │           ├── message_loc: (10,2)-(10,3) = "x"
        │   │           ├── opening_loc: ∅
        │   │           ├── arguments: ∅
        │   │           ├── closing_loc: ∅
        │   │           ├── block: ∅
        │   │           ├── flags: variable_call
        │   │           └── name: :x
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (11,0)-(11,3) = "end"
        ├── @ InterpolatedStringNode (location: (12,0)-(12,10))
        │   ├── opening_loc: (12,0)-(12,10) = "<<-HEREDOC"
        │   ├── parts: (length: 7)
        │   │   ├── @ StringNode (location: (13,0)-(14,0))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (13,0)-(14,0) = "\\\#{}\\\#{}\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\#{}\#{}\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (14,0)-(14,3))
        │   │   │   ├── opening_loc: (14,0)-(14,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (14,2)-(14,3) = "}"
        │   │   ├── @ StringNode (location: (14,3)-(15,0))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (14,3)-(15,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (15,0)-(15,3))
        │   │   │   ├── opening_loc: (15,0)-(15,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (15,2)-(15,3) = "}"
        │   │   ├── @ StringNode (location: (15,3)-(16,0))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (15,3)-(16,0) = "\n"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "\n"
        │   │   ├── @ EmbeddedStatementsNode (location: (16,0)-(16,3))
        │   │   │   ├── opening_loc: (16,0)-(16,2) = "\#{"
        │   │   │   ├── statements: ∅
        │   │   │   └── closing_loc: (16,2)-(16,3) = "}"
        │   │   └── @ StringNode (location: (16,3)-(17,0))
        │   │       ├── flags: ∅
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (16,3)-(17,0) = "\n"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: "\n"
        │   └── closing_loc: (17,0)-(18,0) = "HEREDOC\n"
        ├── @ RescueModifierNode (location: (18,0)-(18,21))
        │   ├── expression:
        │   │   @ InterpolatedStringNode (location: (18,0)-(18,10))
        │   │   ├── opening_loc: (18,0)-(18,10) = "<<-HEREDOC"
        │   │   ├── parts: (length: 2)
        │   │   │   ├── @ EmbeddedStatementsNode (location: (19,0)-(19,3))
        │   │   │   │   ├── opening_loc: (19,0)-(19,2) = "\#{"
        │   │   │   │   ├── statements: ∅
        │   │   │   │   └── closing_loc: (19,2)-(19,3) = "}"
        │   │   │   └── @ StringNode (location: (19,3)-(21,0))
        │   │   │       ├── flags: ∅
        │   │   │       ├── opening_loc: ∅
        │   │   │       ├── content_loc: (19,3)-(21,0) = "\na\n"
        │   │   │       ├── closing_loc: ∅
        │   │   │       └── unescaped: "\na\n"
        │   │   └── closing_loc: (21,0)-(22,0) = "HEREDOC\n"
        │   ├── keyword_loc: (18,11)-(18,17) = "rescue"
        │   └── rescue_expression:
        │       @ NilNode (location: (18,18)-(18,21))
        ├── @ InterpolatedStringNode (location: (22,0)-(22,6))
        │   ├── opening_loc: (22,0)-(22,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (22,1)-(22,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (22,1)-(22,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (22,2)-(22,5))
        │   │       ├── operator_loc: (22,2)-(22,3) = "#"
        │   │       └── variable:
        │   │           @ NumberedReferenceReadNode (location: (22,3)-(22,5))
        │   │           └── number: 1
        │   └── closing_loc: (22,5)-(22,6) = "\""
        ├── @ InterpolatedStringNode (location: (23,0)-(23,6))
        │   ├── opening_loc: (23,0)-(23,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (23,1)-(23,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (23,1)-(23,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (23,2)-(23,5))
        │   │       ├── operator_loc: (23,2)-(23,3) = "#"
        │   │       └── variable:
        │   │           @ GlobalVariableReadNode (location: (23,3)-(23,5))
        │   │           └── name: :$a
        │   └── closing_loc: (23,5)-(23,6) = "\""
        ├── @ InterpolatedStringNode (location: (24,0)-(24,6))
        │   ├── opening_loc: (24,0)-(24,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (24,1)-(24,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (24,1)-(24,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (24,2)-(24,5))
        │   │       ├── operator_loc: (24,2)-(24,3) = "#"
        │   │       └── variable:
        │   │           @ InstanceVariableReadNode (location: (24,3)-(24,5))
        │   │           └── name: :@a
        │   └── closing_loc: (24,5)-(24,6) = "\""
        ├── @ InterpolatedStringNode (location: (25,0)-(25,7))
        │   ├── opening_loc: (25,0)-(25,1) = "\""
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (25,1)-(25,2))
        │   │   │   ├── flags: ∅
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (25,1)-(25,2) = "a"
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "a"
        │   │   └── @ EmbeddedVariableNode (location: (25,2)-(25,6))
        │   │       ├── operator_loc: (25,2)-(25,3) = "#"
        │   │       └── variable:
        │   │           @ ClassVariableReadNode (location: (25,3)-(25,6))
        │   │           └── name: :@@a
        │   └── closing_loc: (25,6)-(25,7) = "\""
        ├── @ IfNode (location: (26,0)-(30,3))
        │   ├── if_keyword_loc: (26,0)-(26,2) = "if"
        │   ├── predicate:
        │   │   @ TrueNode (location: (26,3)-(26,7))
        │   ├── statements:
        │   │   @ StatementsNode (location: (27,2)-(27,19))
        │   │   └── body: (length: 1)
        │   │       └── @ ReturnNode (location: (27,2)-(27,19))
        │   │           ├── keyword_loc: (27,2)-(27,8) = "return"
        │   │           └── arguments:
        │   │               @ ArgumentsNode (location: (27,9)-(27,19))
        │   │               ├── arguments: (length: 1)
        │   │               │   └── @ InterpolatedStringNode (location: (27,9)-(27,19))
        │   │               │       ├── opening_loc: (27,9)-(27,19) = "<<-HEREDOC"
        │   │               │       ├── parts: (length: 3)
        │   │               │       │   ├── @ StringNode (location: (28,0)-(28,4))
        │   │               │       │   │   ├── flags: ∅
        │   │               │       │   │   ├── opening_loc: ∅
        │   │               │       │   │   ├── content_loc: (28,0)-(28,4) = "    "
        │   │               │       │   │   ├── closing_loc: ∅
        │   │               │       │   │   └── unescaped: "    "
        │   │               │       │   ├── @ EmbeddedStatementsNode (location: (28,4)-(28,9))
        │   │               │       │   │   ├── opening_loc: (28,4)-(28,6) = "\#{"
        │   │               │       │   │   ├── statements:
        │   │               │       │   │   │   @ StatementsNode (location: (28,6)-(28,8))
        │   │               │       │   │   │   └── body: (length: 1)
        │   │               │       │   │   │       └── @ IntegerNode (location: (28,6)-(28,8))
        │   │               │       │   │   │           └── flags: decimal
        │   │               │       │   │   └── closing_loc: (28,8)-(28,9) = "}"
        │   │               │       │   └── @ StringNode (location: (28,9)-(29,0))
        │   │               │       │       ├── flags: ∅
        │   │               │       │       ├── opening_loc: ∅
        │   │               │       │       ├── content_loc: (28,9)-(29,0) = "\n"
        │   │               │       │       ├── closing_loc: ∅
        │   │               │       │       └── unescaped: "\n"
        │   │               │       └── closing_loc: (29,0)-(30,0) = "  HEREDOC\n"
        │   │               └── flags: ∅
        │   ├── consequent: ∅
        │   └── end_keyword_loc: (30,0)-(30,3) = "end"
        ├── @ CallNode (location: (31,0)-(31,15))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (31,0)-(31,3) = "foo"
        │   ├── opening_loc: (31,3)-(31,4) = "("
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (31,4)-(31,14))
        │   │   ├── arguments: (length: 1)
        │   │   │   └── @ InterpolatedStringNode (location: (31,4)-(31,14))
        │   │   │       ├── opening_loc: (31,4)-(31,14) = "<<-HEREDOC"
        │   │   │       ├── parts: (length: 3)
        │   │   │       │   ├── @ StringNode (location: (32,0)-(32,2))
        │   │   │       │   │   ├── flags: ∅
        │   │   │       │   │   ├── opening_loc: ∅
        │   │   │       │   │   ├── content_loc: (32,0)-(32,2) = "  "
        │   │   │       │   │   ├── closing_loc: ∅
        │   │   │       │   │   └── unescaped: "  "
        │   │   │       │   ├── @ EmbeddedStatementsNode (location: (32,2)-(32,8))
        │   │   │       │   │   ├── opening_loc: (32,2)-(32,4) = "\#{"
        │   │   │       │   │   ├── statements:
        │   │   │       │   │   │   @ StatementsNode (location: (32,4)-(32,7))
        │   │   │       │   │   │   └── body: (length: 1)
        │   │   │       │   │   │       └── @ CallNode (location: (32,4)-(32,7))
        │   │   │       │   │   │           ├── receiver: ∅
        │   │   │       │   │   │           ├── call_operator_loc: ∅
        │   │   │       │   │   │           ├── message_loc: (32,4)-(32,7) = "bar"
        │   │   │       │   │   │           ├── opening_loc: ∅
        │   │   │       │   │   │           ├── arguments: ∅
        │   │   │       │   │   │           ├── closing_loc: ∅
        │   │   │       │   │   │           ├── block: ∅
        │   │   │       │   │   │           ├── flags: variable_call
        │   │   │       │   │   │           └── name: :bar
        │   │   │       │   │   └── closing_loc: (32,7)-(32,8) = "}"
        │   │   │       │   └── @ StringNode (location: (32,8)-(33,0))
        │   │   │       │       ├── flags: ∅
        │   │   │       │       ├── opening_loc: ∅
        │   │   │       │       ├── content_loc: (32,8)-(33,0) = "\n"
        │   │   │       │       ├── closing_loc: ∅
        │   │   │       │       └── unescaped: "\n"
        │   │   │       └── closing_loc: (33,0)-(34,0) = "HEREDOC\n"
        │   │   └── flags: ∅
        │   ├── closing_loc: (31,14)-(31,15) = ")"
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: :foo
        └── @ CallNode (location: (34,0)-(37,1))
            ├── receiver: ∅
            ├── call_operator_loc: ∅
            ├── message_loc: (34,0)-(34,3) = "foo"
            ├── opening_loc: (34,3)-(34,4) = "("
            ├── arguments:
            │   @ ArgumentsNode (location: (34,4)-(34,14))
            │   ├── arguments: (length: 1)
            │   │   └── @ InterpolatedStringNode (location: (34,4)-(34,14))
            │   │       ├── opening_loc: (34,4)-(34,14) = "<<-HEREDOC"
            │   │       ├── parts: (length: 3)
            │   │       │   ├── @ StringNode (location: (35,0)-(35,2))
            │   │       │   │   ├── flags: ∅
            │   │       │   │   ├── opening_loc: ∅
            │   │       │   │   ├── content_loc: (35,0)-(35,2) = "  "
            │   │       │   │   ├── closing_loc: ∅
            │   │       │   │   └── unescaped: "  "
            │   │       │   ├── @ EmbeddedStatementsNode (location: (35,2)-(35,8))
            │   │       │   │   ├── opening_loc: (35,2)-(35,4) = "\#{"
            │   │       │   │   ├── statements:
            │   │       │   │   │   @ StatementsNode (location: (35,4)-(35,7))
            │   │       │   │   │   └── body: (length: 1)
            │   │       │   │   │       └── @ CallNode (location: (35,4)-(35,7))
            │   │       │   │   │           ├── receiver: ∅
            │   │       │   │   │           ├── call_operator_loc: ∅
            │   │       │   │   │           ├── message_loc: (35,4)-(35,7) = "bar"
            │   │       │   │   │           ├── opening_loc: ∅
            │   │       │   │   │           ├── arguments: ∅
            │   │       │   │   │           ├── closing_loc: ∅
            │   │       │   │   │           ├── block: ∅
            │   │       │   │   │           ├── flags: variable_call
            │   │       │   │   │           └── name: :bar
            │   │       │   │   └── closing_loc: (35,7)-(35,8) = "}"
            │   │       │   └── @ StringNode (location: (35,8)-(36,0))
            │   │       │       ├── flags: ∅
            │   │       │       ├── opening_loc: ∅
            │   │       │       ├── content_loc: (35,8)-(36,0) = "\n"
            │   │       │       ├── closing_loc: ∅
            │   │       │       └── unescaped: "\n"
            │   │       └── closing_loc: (36,0)-(37,0) = "HEREDOC\n"
            │   └── flags: ∅
            ├── closing_loc: (34,14)-(34,15) = ")"
            ├── block:
            │   @ BlockNode (location: (34,16)-(37,1))
            │   ├── locals: [:x]
            │   ├── parameters:
            │   │   @ BlockParametersNode (location: (34,18)-(34,21))
            │   │   ├── parameters:
            │   │   │   @ ParametersNode (location: (34,19)-(34,20))
            │   │   │   ├── requireds: (length: 1)
            │   │   │   │   └── @ RequiredParameterNode (location: (34,19)-(34,20))
            │   │   │   │       └── name: :x
            │   │   │   ├── optionals: (length: 0)
            │   │   │   ├── rest: ∅
            │   │   │   ├── posts: (length: 0)
            │   │   │   ├── keywords: (length: 0)
            │   │   │   ├── keyword_rest: ∅
            │   │   │   └── block: ∅
            │   │   ├── locals: (length: 0)
            │   │   ├── opening_loc: (34,18)-(34,19) = "|"
            │   │   └── closing_loc: (34,20)-(34,21) = "|"
            │   ├── body: ∅
            │   ├── opening_loc: (34,16)-(34,17) = "{"
            │   └── closing_loc: (37,0)-(37,1) = "}"
            ├── flags: ∅
            └── name: :foo
