@ ProgramNode (location: (0...293))
├── locals: [:foo]
└── statements:
    @ StatementsNode (location: (0...293))
    └── body: (length: 14)
        ├── @ CallNode (location: (0...9))
        │   ├── receiver: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (0...3) = "foo"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (4...9))
        │   │   └── arguments: (length: 1)
        │   │       └── @ RegularExpressionNode (location: (4...9))
        │   │           ├── opening_loc: (4...5) = "/"
        │   │           ├── content_loc: (5...8) = "bar"
        │   │           ├── closing_loc: (8...9) = "/"
        │   │           ├── unescaped: "bar"
        │   │           └── flags: ∅
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "foo"
        ├── @ RegularExpressionNode (location: (11...19))
        │   ├── opening_loc: (11...14) = "%r{"
        │   ├── content_loc: (14...17) = "abc"
        │   ├── closing_loc: (17...19) = "}i"
        │   ├── unescaped: "abc"
        │   └── flags: ignore_case
        ├── @ RegularExpressionNode (location: (21...26))
        │   ├── opening_loc: (21...22) = "/"
        │   ├── content_loc: (22...25) = "a\\b"
        │   ├── closing_loc: (25...26) = "/"
        │   ├── unescaped: "a\b"
        │   └── flags: ∅
        ├── @ InterpolatedRegularExpressionNode (location: (28...39))
        │   ├── opening_loc: (28...29) = "/"
        │   ├── parts: (length: 2)
        │   │   ├── @ StringNode (location: (29...33))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (29...33) = "aaa "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "aaa "
        │   │   └── @ EmbeddedVariableNode (location: (33...38))
        │   │       ├── operator_loc: (33...34) = "#"
        │   │       └── variable:
        │   │           @ GlobalVariableReadNode (location: (34...38))
        │   │           └── name: :$bbb
        │   ├── closing_loc: (38...39) = "/"
        │   └── flags: ∅
        ├── @ InterpolatedRegularExpressionNode (location: (41...57))
        │   ├── opening_loc: (41...42) = "/"
        │   ├── parts: (length: 3)
        │   │   ├── @ StringNode (location: (42...46))
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── content_loc: (42...46) = "aaa "
        │   │   │   ├── closing_loc: ∅
        │   │   │   └── unescaped: "aaa "
        │   │   ├── @ EmbeddedStatementsNode (location: (46...52))
        │   │   │   ├── opening_loc: (46...48) = "\#{"
        │   │   │   ├── statements:
        │   │   │   │   @ StatementsNode (location: (48...51))
        │   │   │   │   └── body: (length: 1)
        │   │   │   │       └── @ CallNode (location: (48...51))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (48...51) = "bbb"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "bbb"
        │   │   │   └── closing_loc: (51...52) = "}"
        │   │   └── @ StringNode (location: (52...56))
        │   │       ├── opening_loc: ∅
        │   │       ├── content_loc: (52...56) = " ccc"
        │   │       ├── closing_loc: ∅
        │   │       └── unescaped: " ccc"
        │   ├── closing_loc: (56...57) = "/"
        │   └── flags: ∅
        ├── @ ArrayNode (location: (59...86))
        │   ├── elements: (length: 2)
        │   │   ├── @ CallNode (location: (60...80))
        │   │   │   ├── receiver:
        │   │   │   │   @ RegularExpressionNode (location: (60...73))
        │   │   │   │   ├── opening_loc: (60...61) = "/"
        │   │   │   │   ├── content_loc: (61...72) = "(?<foo>bar)"
        │   │   │   │   ├── closing_loc: (72...73) = "/"
        │   │   │   │   ├── unescaped: "(?<foo>bar)"
        │   │   │   │   └── flags: ∅
        │   │   │   ├── call_operator_loc: ∅
        │   │   │   ├── message_loc: (74...76) = "=~"
        │   │   │   ├── opening_loc: ∅
        │   │   │   ├── arguments:
        │   │   │   │   @ ArgumentsNode (location: (77...80))
        │   │   │   │   └── arguments: (length: 1)
        │   │   │   │       └── @ CallNode (location: (77...80))
        │   │   │   │           ├── receiver: ∅
        │   │   │   │           ├── call_operator_loc: ∅
        │   │   │   │           ├── message_loc: (77...80) = "baz"
        │   │   │   │           ├── opening_loc: ∅
        │   │   │   │           ├── arguments: ∅
        │   │   │   │           ├── closing_loc: ∅
        │   │   │   │           ├── block: ∅
        │   │   │   │           ├── flags: variable_call
        │   │   │   │           └── name: "baz"
        │   │   │   ├── closing_loc: ∅
        │   │   │   ├── block: ∅
        │   │   │   ├── flags: ∅
        │   │   │   └── name: "=~"
        │   │   └── @ LocalVariableReadNode (location: (82...85))
        │   │       ├── name: :foo
        │   │       └── depth: 0
        │   ├── opening_loc: (59...60) = "["
        │   └── closing_loc: (85...86) = "]"
        ├── @ RegularExpressionNode (location: (88...94))
        │   ├── opening_loc: (88...89) = "/"
        │   ├── content_loc: (89...92) = "abc"
        │   ├── closing_loc: (92...94) = "/i"
        │   ├── unescaped: "abc"
        │   └── flags: ignore_case
        ├── @ RegularExpressionNode (location: (96...122))
        │   ├── opening_loc: (96...99) = "%r/"
        │   ├── content_loc: (99...120) = "[a-z$._?][\\w$.?\#@~]*:"
        │   ├── closing_loc: (120...122) = "/i"
        │   ├── unescaped: "[a-z$._?][w$.?\#@~]*:"
        │   └── flags: ignore_case
        ├── @ RegularExpressionNode (location: (124...161))
        │   ├── opening_loc: (124...127) = "%r/"
        │   ├── content_loc: (127...159) = "([a-z$._?][\\w$.?\#@~]*)(\\s+)(equ)"
        │   ├── closing_loc: (159...161) = "/i"
        │   ├── unescaped: "([a-z$._?][w$.?\#@~]*)( +)(equ)"
        │   └── flags: ignore_case
        ├── @ RegularExpressionNode (location: (163...188))
        │   ├── opening_loc: (163...166) = "%r/"
        │   ├── content_loc: (166...186) = "[a-z$._?][\\w$.?\#@~]*"
        │   ├── closing_loc: (186...188) = "/i"
        │   ├── unescaped: "[a-z$._?][w$.?\#@~]*"
        │   └── flags: ignore_case
        ├── @ RegularExpressionNode (location: (190...249))
        │   ├── opening_loc: (190...193) = "%r("
        │   ├── content_loc: (193...248) = "\n(?:[\\w\#$%_']|\\(\\)|\\(,\\)|\\[\\]|[0-9])*\n  (?:[\\w\#$%_']+)\n"
        │   ├── closing_loc: (248...249) = ")"
        │   ├── unescaped: "\n(?:[w\#$%_']|()|(,)|[]|[0-9])*\n  (?:[w\#$%_']+)\n"
        │   └── flags: ∅
        ├── @ CallNode (location: (251...267))
        │   ├── receiver:
        │   │   @ RegularExpressionNode (location: (251...259))
        │   │   ├── opening_loc: (251...252) = "/"
        │   │   ├── content_loc: (252...258) = "(?#\\))"
        │   │   ├── closing_loc: (258...259) = "/"
        │   │   ├── unescaped: "(?#))"
        │   │   └── flags: ∅
        │   ├── call_operator_loc: ∅
        │   ├── message_loc: (260...262) = "=~"
        │   ├── opening_loc: ∅
        │   ├── arguments:
        │   │   @ ArgumentsNode (location: (263...267))
        │   │   └── arguments: (length: 1)
        │   │       └── @ StringNode (location: (263...267))
        │   │           ├── opening_loc: (263...264) = "\""
        │   │           ├── content_loc: (264...266) = "hi"
        │   │           ├── closing_loc: (266...267) = "\""
        │   │           └── unescaped: "hi"
        │   ├── closing_loc: ∅
        │   ├── block: ∅
        │   ├── flags: ∅
        │   └── name: "=~"
        ├── @ RegularExpressionNode (location: (269...278))
        │   ├── opening_loc: (269...272) = "%r#"
        │   ├── content_loc: (272...277) = "pound"
        │   ├── closing_loc: (277...278) = "#"
        │   ├── unescaped: "pound"
        │   └── flags: ∅
        └── @ InterpolatedRegularExpressionNode (location: (280...293))
            ├── opening_loc: (280...281) = "/"
            ├── parts: (length: 2)
            │   ├── @ StringNode (location: (281...285))
            │   │   ├── opening_loc: ∅
            │   │   ├── content_loc: (281...285) = "aaa "
            │   │   ├── closing_loc: ∅
            │   │   └── unescaped: "aaa "
            │   └── @ EmbeddedStatementsNode (location: (285...291))
            │       ├── opening_loc: (285...287) = "\#{"
            │       ├── statements:
            │       │   @ StatementsNode (location: (287...290))
            │       │   └── body: (length: 1)
            │       │       └── @ CallNode (location: (287...290))
            │       │           ├── receiver: ∅
            │       │           ├── call_operator_loc: ∅
            │       │           ├── message_loc: (287...290) = "bbb"
            │       │           ├── opening_loc: ∅
            │       │           ├── arguments: ∅
            │       │           ├── closing_loc: ∅
            │       │           ├── block: ∅
            │       │           ├── flags: variable_call
            │       │           └── name: "bbb"
            │       └── closing_loc: (290...291) = "}"
            ├── closing_loc: (291...293) = "/o"
            └── flags: once
